From 880653d31a8f1ff8384fdbc75b84934bceecfdb8 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Sat, 18 Nov 2000 06:43:49 +0000 Subject: Initial revision --- gl4java/GL4JavaInitException.java | 10 + gl4java/GL4JavaReflections.java | 163 + gl4java/GLContext.java.skel | 2251 ++++++ gl4java/GLEnum.java | 1347 ++++ gl4java/GLFunc.java | 7438 ++++++++++++++++++++ gl4java/GLFuncJauJNI.java | 6997 ++++++++++++++++++ gl4java/GLFuncJauJNInf.java | 6997 ++++++++++++++++++ gl4java/GLUEnum.java | 141 + gl4java/GLUFunc.java | 774 ++ gl4java/GLUFuncJauJNI.java | 848 +++ gl4java/GLUFuncJauJNInf.java | 848 +++ gl4java/applet/SimpleGLAnimApplet1.java | 270 + gl4java/awt/GLAnimCanvas.java | 686 ++ gl4java/awt/GLCanvas.java | 695 ++ gl4java/awt/GLImageCanvas.java | 402 ++ gl4java/jau/awt/WinHandleAccess.java | 21 + gl4java/jau/awt/macintosh/MacHandleAccess.java | 89 + gl4java/jau/awt/motif/X11HandleAccess.java | 86 + gl4java/jau/awt/windows/MSWin32HandleAccess.java | 60 + gl4java/jau/awt/windows/Win32HandleAccess.java | 84 + gl4java/swing/GLAnimJPanel.java | 720 ++ gl4java/swing/GLJPanel.java | 865 +++ gl4java/swing/GLJPanel.java,v | 959 +++ gl4java/swing/SimpleGLJApplet1.java | 292 + gl4java/system/GljMSJDirect.java | 77 + gl4java/utils/Test.java | 359 + gl4java/utils/Tool.java | 158 + gl4java/utils/glut/GLUTEnum.java | 40 + gl4java/utils/glut/GLUTFunc.java | 54 + gl4java/utils/glut/GLUTFuncLightImpl.java | 847 +++ gl4java/utils/glut/fonts/BitmapCharRec.java | 28 + gl4java/utils/glut/fonts/BitmapFontRec.java | 24 + gl4java/utils/glut/fonts/CoordRec.java | 19 + gl4java/utils/glut/fonts/GLUTBitmapFont.java | 12 + .../glut/fonts/GLUTFuncLightImplWithFonts.java | 300 + gl4java/utils/glut/fonts/GLUTStrokeFont.java | 5 + gl4java/utils/glut/fonts/LICENSE.txt | 28 + gl4java/utils/glut/fonts/Makefile | 110 + gl4java/utils/glut/fonts/MonoRoman.stroke | 503 ++ gl4java/utils/glut/fonts/Roman.stroke | 604 ++ gl4java/utils/glut/fonts/StrokeCharRec.java | 24 + gl4java/utils/glut/fonts/StrokeFontRec.java | 25 + gl4java/utils/glut/fonts/StrokeRec.java | 20 + gl4java/utils/glut/fonts/capturexfont.c | 371 + gl4java/utils/glut/fonts/data/glutBitmap8By13.java | 2048 ++++++ gl4java/utils/glut/fonts/data/glutBitmap9By15.java | 2050 ++++++ .../glut/fonts/data/glutBitmapHelvetica10.java | 1769 +++++ .../glut/fonts/data/glutBitmapHelvetica12.java | 1779 +++++ .../glut/fonts/data/glutBitmapHelvetica18.java | 1888 +++++ .../glut/fonts/data/glutBitmapTimesRoman10.java | 1768 +++++ .../glut/fonts/data/glutBitmapTimesRoman24.java | 2051 ++++++ .../utils/glut/fonts/data/glutStrokeMonoRoman.java | 2458 +++++++ gl4java/utils/glut/fonts/data/glutStrokeRoman.java | 2458 +++++++ gl4java/utils/glut/fonts/stroke.h | 134 + gl4java/utils/glut/fonts/strokegen.y | 658 ++ gl4java/utils/glut/fonts/strokelex.l | 134 + gl4java/utils/textures/AWTTextureLoader.java | 169 + gl4java/utils/textures/IOTextureLoader.java | 67 + gl4java/utils/textures/PPMAsciiTextureLoader.java | 88 + gl4java/utils/textures/PngTextureLoader.java | 160 + gl4java/utils/textures/TGATextureGrabber.java | 61 + gl4java/utils/textures/TGATextureLoader.java | 111 + gl4java/utils/textures/TextureGrabber.java | 116 + gl4java/utils/textures/TextureLoader.java | 41 + gl4java/utils/textures/TextureTool.java | 610 ++ 65 files changed, 57269 insertions(+) create mode 100644 gl4java/GL4JavaInitException.java create mode 100644 gl4java/GL4JavaReflections.java create mode 100644 gl4java/GLContext.java.skel create mode 100644 gl4java/GLEnum.java create mode 100644 gl4java/GLFunc.java create mode 100644 gl4java/GLFuncJauJNI.java create mode 100644 gl4java/GLFuncJauJNInf.java create mode 100644 gl4java/GLUEnum.java create mode 100644 gl4java/GLUFunc.java create mode 100644 gl4java/GLUFuncJauJNI.java create mode 100644 gl4java/GLUFuncJauJNInf.java create mode 100644 gl4java/applet/SimpleGLAnimApplet1.java create mode 100644 gl4java/awt/GLAnimCanvas.java create mode 100644 gl4java/awt/GLCanvas.java create mode 100755 gl4java/awt/GLImageCanvas.java create mode 100644 gl4java/jau/awt/WinHandleAccess.java create mode 100644 gl4java/jau/awt/macintosh/MacHandleAccess.java create mode 100644 gl4java/jau/awt/motif/X11HandleAccess.java create mode 100644 gl4java/jau/awt/windows/MSWin32HandleAccess.java create mode 100644 gl4java/jau/awt/windows/Win32HandleAccess.java create mode 100644 gl4java/swing/GLAnimJPanel.java create mode 100644 gl4java/swing/GLJPanel.java create mode 100644 gl4java/swing/GLJPanel.java,v create mode 100644 gl4java/swing/SimpleGLJApplet1.java create mode 100644 gl4java/system/GljMSJDirect.java create mode 100644 gl4java/utils/Test.java create mode 100644 gl4java/utils/Tool.java create mode 100644 gl4java/utils/glut/GLUTEnum.java create mode 100644 gl4java/utils/glut/GLUTFunc.java create mode 100644 gl4java/utils/glut/GLUTFuncLightImpl.java create mode 100644 gl4java/utils/glut/fonts/BitmapCharRec.java create mode 100644 gl4java/utils/glut/fonts/BitmapFontRec.java create mode 100644 gl4java/utils/glut/fonts/CoordRec.java create mode 100644 gl4java/utils/glut/fonts/GLUTBitmapFont.java create mode 100644 gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java create mode 100644 gl4java/utils/glut/fonts/GLUTStrokeFont.java create mode 100644 gl4java/utils/glut/fonts/LICENSE.txt create mode 100644 gl4java/utils/glut/fonts/Makefile create mode 100644 gl4java/utils/glut/fonts/MonoRoman.stroke create mode 100644 gl4java/utils/glut/fonts/Roman.stroke create mode 100644 gl4java/utils/glut/fonts/StrokeCharRec.java create mode 100644 gl4java/utils/glut/fonts/StrokeFontRec.java create mode 100644 gl4java/utils/glut/fonts/StrokeRec.java create mode 100644 gl4java/utils/glut/fonts/capturexfont.c create mode 100644 gl4java/utils/glut/fonts/data/glutBitmap8By13.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmap9By15.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java create mode 100644 gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java create mode 100644 gl4java/utils/glut/fonts/data/glutStrokeRoman.java create mode 100644 gl4java/utils/glut/fonts/stroke.h create mode 100644 gl4java/utils/glut/fonts/strokegen.y create mode 100644 gl4java/utils/glut/fonts/strokelex.l create mode 100644 gl4java/utils/textures/AWTTextureLoader.java create mode 100644 gl4java/utils/textures/IOTextureLoader.java create mode 100644 gl4java/utils/textures/PPMAsciiTextureLoader.java create mode 100644 gl4java/utils/textures/PngTextureLoader.java create mode 100644 gl4java/utils/textures/TGATextureGrabber.java create mode 100644 gl4java/utils/textures/TGATextureLoader.java create mode 100644 gl4java/utils/textures/TextureGrabber.java create mode 100644 gl4java/utils/textures/TextureLoader.java create mode 100755 gl4java/utils/textures/TextureTool.java (limited to 'gl4java') diff --git a/gl4java/GL4JavaInitException.java b/gl4java/GL4JavaInitException.java new file mode 100644 index 0000000..93975fc --- /dev/null +++ b/gl4java/GL4JavaInitException.java @@ -0,0 +1,10 @@ + +package gl4java; + + +public class GL4JavaInitException extends Exception +{ + + public GL4JavaInitException () + { super(); } +} diff --git a/gl4java/GL4JavaReflections.java b/gl4java/GL4JavaReflections.java new file mode 100644 index 0000000..79969bf --- /dev/null +++ b/gl4java/GL4JavaReflections.java @@ -0,0 +1,163 @@ + +/** + * @(#) GL4JavaReflections.java + */ + +package gl4java; + +import java.lang.System; +import java.lang.String; +import java.lang.reflect.*; + +/** + * The function-declaration holder ! + * + * @see CFuncVariable + * @version 1.00, 12. Novemeber 1999 + * @author Sven Goethel + * + */ +public class GL4JavaReflections + implements Cloneable +{ + public Object methodClassInstance=null; + public Class type=null; + public String methodName=null; + public Class[] argList=null; + + public GL4JavaReflections ( Object methodClassInstance, + Class type, String methodName, + Class[] argList ) + { + this.methodClassInstance=methodClassInstance; + this.type=type; + this.methodName=methodName; + this.argList=argList; + } + + protected Object clone() + throws CloneNotSupportedException + { + int i; + Class[] args = new Class[argList.length]; + + for(i=0; i + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 
+        The GL4Java Documentation
+ *
+ *

+ * + * All native libraries and GLFunc* and GLUFunc* implementations + * can/should be loaded right here ! + * + * 

+ 	loadNativeLibraries
+ 	createGLFunc
+ 	createGLUFunc
+        

+        To check the library versions, you can start the 
+ 	main
+        function with java gl4java.GLContext
+ *
+ * + *

+ * + * This class creates a GLContext in the constructor which fits to the native Window + * of the given Component ! + * + * 

+   	glc2glj - A simple c to java converter for C- and GL-types
+ *
+ *

+ * + * The native libraries are plattform depended. + * + * 

+	  The default native library for Win32 and Unice's is :
+	  

+	  	GLContext:	GL4JavaJauGljJNI
+		GLFuncJauJNI:	GL4JavaJauGLJNI
+		GLUFuncJauJNI:	GL4JavaJauGLUJNI
+	  

+		Note:
+	  

+	  The default native library for Macintosh is :
+	  

+	  	GLContext:	GL4JavaMacGZGljJNI
+		GLFuncJauJNI:	GL4JavaMacGZGLJNI
+		GLUFuncJauJNI:	GL4JavaMacGZGLUJNI
+	  

+	  

+	  To check wich version and vendors are currently used,
+	  just call while a GLContext is created :
+	  

+	  gljShowVersions
+	  

+	  Where an own Frame is opened !
+ *
+ * + * Make sure that this library is installed in your library path. + * The library path is for Unices one path of the environment + * variable ´LD_LIBRARY_PATH´ and for Windows 32 + * ´c:/winnt/system32´ (WinNT) or 'c:/windows/system' (Windows 95) . + * Or it should be installed in the 'jre/bin' or + * 'Netscape/communicator/Program/java/bin' path ! + * + *

+ * + * To have a convinient usage, e.g. automatic resizing, GLContext + * and painting/gl-rendering, some classes in the package gl4java.awt + * may help you. + * + * 

+          E.g.: gl4java.awt.GLCanvas 
+	  

+	  init to create the java-stuff and GL-inits 
+	  display to render one frame, called by paint
+	  reshape to reshape (window resize)
+          

+          Or look for animation at 
+	  gl4java.awt.GLAnimCanvas !
+ *
+ * + *

+ * + * IF you remove/release a The component which is binded to this GLContext, + * you have to release the GLContext also - while calling: + * + * 

+ 	gljDestroy
+ *
+ * + * before releasing/dispose it´s Window ! + * + *

+ * + * We also define our own OpenGL extension. This extension functions + * start with the prefix glj like you can see here: + * + * 

+        THIS FUNCTIONS ARE FOR USERS PURPOSES:
+	======================================
+
+ 	loadNativeLibraries
+ 	createGLFunc
+ 	createGLUFunc
+ 	gljGetNativeLibVersion
+ 	gljGetClassVersion
+	gljShowVersions
+ 	gljCheckGL
+ 	gljCheckGLTypes
+ 	gljResize
+ 	gljSwap
+ 	gljIsInit
+ 	gljMakeCurrent
+ 	gljDestroy
+ 	gljFree
+
+ *
+ *

+ * + * You can see our example demo sources: + * 

+	olympicCvs.java as java source
+	glLogoCvs.java as java source
+	glDemosCvs.java as java source
+ *
+ *

+ * + * If you are interessting in further Documentation, downloading the latest + * version, and/or the history of GL4Java click on the following link. + * + * 

+	The GL4Java Homepage
+ *
+ *

+ * + * @see WinDataAccess + * @version 2.00, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLContext extends Object + implements Runnable +{ + + protected boolean isInitialized = false; + + /** + * Flag is the native library is loaded. + * The native library is loaded at startup. + * If we failed loading the lib., + * gljMakeCurrent and gljIsInit will return false. + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljIsInit + */ + protected static boolean libsLoaded = false; + + /** + * The default GLContext native library for Windows 95/NT && MS-JVM + * + */ + public static final String defGljMSWinLib = "GL4JavaGljMSJDirect" ; + + /** + * The default GLContext native library for all + * + */ + public static final String defGljLib = "GL4JavaJauGljJNI" ; + + /** + * The default GLFunc implementation + * + */ + public static final String defGLFuncClass = "GLFuncJauJNI" ; + + /** + * The default GLFunc native library for all + */ + public static final String defGLFuncLib = "GL4JavaJauGLJNI" ; + + /** + * The default GLUFunc implementation + * + */ + public static final String defGLUFuncClass = "GLUFuncJauJNI" ; + + /** + * The default GLUFunc native library for all + */ + public static final String defGLUFuncLib = "GL4JavaJauGLUJNI" ; + + + /** + * the version of this java-class + * + * ... + * + * Each is dezimal ! + */ + public static final String version = __SED_CLASS_VERSION__ ; + + /** + * Flag's to enable/disable verbose Information. + * Usually for debugging. + */ + public static boolean gljClassDebug = false; + public static boolean gljNativeDebug = false; + + /** + * We will store the GL Context right here. + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected int glContext=0; + + /** + * The context with witch display lists and textures will be shared. + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected GLContext sharedGLContext; + protected int sharedGLContextNative= 0; // No sharing by default. + + /** + * Xwindow data AND Windows data for the widget + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected int pixmapHandle=0; // unique handle for the Pixmap + protected int windowHandle=0; // unique handle for this widget's window + protected int displayHandle=0; // unqiue handle to the display + + /** + * MS-JDirect-Window data for the MS-JVM interface + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + private int createwinx; + private int createwiny; + private int createwinw; + private int createwinh; + private boolean threadRunning = false; + private boolean destroyWindow = false; + protected Container containerWindow = null; + + /** + * The custom set offscreen Size + * + * If this is set to != null, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * Must be set via createOffScreenCtx + * + * @see GLJPanel#paint + * @see GLJPanel#createOffScreenCtx + */ + protected Dimension offScrnSize = null; + + /** + * Windows data AND flag is Window-Handel is read (for X11 also) ! + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + int pData = 0; // stores the pointer structure that holds windows info + + /** + * Flag to check, if the OpenGL-Context is active ! + * + * @see GLCanvas#gljIsEnabled + * @see GLCanvas#gljSetEnabled + */ + protected boolean glEnabled = true; + + /** + * Do we use offscreen rendering + * X11: pixmap eq window-ressources, + * window eq. GLXPixmap a GLXDrawable + * glContext eq. GLXContext + * + * This is set via the constructor ! + * + * @see GLContext#GLContext + */ + protected boolean offScreenRenderer = false; + + /** + * Do we use doubleBuffer - of course ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isDoubleBuffer + * @see GLContext#GLContext + */ + protected boolean doubleBuffer = true; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * + * @see GLContext#GLContext + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator-size number, default: 0 + * + * This value has a special behavior. + * For input - within the contructor, + * it is the value for each component ! + * + * The output value, after the constructor returns, + * it is the summary of all accumulation bits of all components ! + * + * @see GLContext#GLContext + */ + protected int accumSize = 0; + + /** + * Do we use stereoView - not yet ;-) ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isStereoView + * @see GLContext#GLContext + */ + protected boolean stereoView = false; + + /** + * Do we use True-Color RGBA - of course ;-) ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isRGBA + * @see GLContext#GLContext + */ + protected boolean rgba = true; + + /** + * We normally do not have to create an own Window ! + * This is the default visual property ... ! + * But some machines, like SGI's Irix, + * must use an own created overlapped window ! + * For these machines, a compiler flag is set, + * so that this value is alsways set to true ! + * + * This is set via the constructor ! + * + * @see GLContext#isOwnWindowCreated + * @see GLContext#GLContext + */ + protected boolean createOwnWindow = false; + + /** + * The resize flag, which indicates a resize for the next paint function ! + * This flag will bes set in 'componentResized' + * and will be cleared after resize (glViewport) in sDisplay !! + * + * @see gl4java.awt.GLCanvas#sDisplay + */ + protected boolean mustResize = false; + + protected Dimension size = null; + + /** + * the light- or heavy component + * where GL commands should be drawn + */ + protected Component _comp = null; + + /** + * the heavy component + * where GL commands should be drawn + * + * if the _comp component is a swing (light) + * component, this component contains its heavy parent ! + */ + protected Component _compHeavy = null; + + /** + * Variable to tell is where windows or not (X11) + * Usally X11 ;-)) + * + * Ok - lets give one to the Max :-) + */ + public static final int + OsWindoof = -1, + OsUnknown = 0, + OsX11 = 1, + OsMac = 2; // for Gerard Ziemski's port + + private static int osType=OsUnknown; + + private static boolean isNetscapeJvm = false; + private static boolean isMicrosoftJvm = false; + private static boolean useMSJDirect = false; + private static String jvmVendor = null; + private static String jvmVersion = null; + private static int jvmVersionMajor = 1; // min. defaults + private static int jvmVersionMinor = 1; // min. defaults + private static String osName = null; + + /** + * Get the native GL Context ! + * + * @see GLContext#glContext + */ + public final long getNativeGLContext() { return (long)glContext; } + + /** + * Get the native Window Handle ! + * + * @see GLContext#windowHandle + */ + public final long getNativeWindoHandle() { return (long)windowHandle; } + + /** + * Get the optional shared GL Context ! + * + * @see GLContext#sharedGLContext + */ + public final GLContext getSharedGLContext() { return sharedGLContext; } + + /** + * Get the native OS-Type ! + * + * @see GLContext#osType + * @see GLContext#OsWindoof + * @see GLContext#OsUnknown + * @see GLContext#OsX11 + * @see GLContext#OsMac + */ + public final int getNativeOSType() { return osType; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#doubleBuffer + * @see GLContext#GLContext + */ + public final boolean isDoubleBuffer() { return doubleBuffer; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#stereoView + * @see GLContext#GLContext + */ + public final int getStencilBitNumber() { return stencilBits; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#GLContext + */ + public final int getAccumSize() { return accumSize; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#stereoView + * @see GLContext#GLContext + */ + public final boolean isStereoView() { return stereoView; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#rgba + * @see GLContext#GLContext + */ + public final boolean isRGBA() { return rgba; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#createOwnWindow + * @see GLContext#GLContext + */ + public final boolean isOwnWindowCreated() { return createOwnWindow; } + + /** + * Support of loading the native library seperatly. + * + * Link with the native OpenGL library. If we cannot link, an exception + * is thrown. + * The name of the library is named e.g.: "GL4JavaJauGljJNI" at the + * Java level, or "libGL4JavaJauGljJNI.so" at the solaris level, + * or "GL4JavaJauGljJNI.dll" at the win32 level :-). + * + * @param gljLibName The name of the GLContex native library. + * If gljLibName==null, the default library will be used ! + * + * @param glLibName The name of the GLFunc native library. + * If glLibName==null, the default library will be used ! + * + * @param gluLibName The name of the GLUFunc native library. + * If gluLibName==null, the default library will be used ! + * + * @return boolean, true if succesfull ! + * + * @see GLContext#defGljLib + * + * @see GLContext#defGLFuncLib + * + * @see GLContext#defGLUFuncLib + */ + public static boolean loadNativeLibraries ( String gljLibName, + String glLibName, + String gluLibName + ) + { + if(libsLoaded) return true; + + String libNames[] = null; + + jvmVendor = java.lang.System.getProperty("java.vendor"); + jvmVersion = java.lang.System.getProperty("java.version"); + + if(gljClassDebug) + { + System.out.println("jvm vendor: "+jvmVendor); + System.out.println("jvm version: "+jvmVersion); + } + + int i0 = 0; + int i1 = jvmVersion.indexOf(".", i0); + String strhlp = null; + if(i1>0) + { + strhlp = jvmVersion.substring(i0,i1); + try { + jvmVersionMajor = Integer.valueOf(strhlp).intValue(); + } catch (Exception e) + {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");} + } + i0 = i1+1; + i1 = jvmVersion.indexOf(".", i0); + if( i1 < 0 ) + i1 = jvmVersion.length(); // no 2nd dot, no bug version number + + if( 0=0 ; + isMicrosoftJvm = jvmVendor!=null && jvmVendor.indexOf("Microsoft")>=0 ; + + // Determine the OS + osName = System.getProperty( "os.name" ); + if( osName.startsWith( "Wind" ) ) + osType = OsWindoof; + else if( osName.startsWith( "Mac OS" ) ) + osType = OsMac; + else /* oops - lets guess unix/x11 :-) */ + osType = OsX11; + + String jniEXTsuff = ""; + + if( jvmVersionMajor>=2 || + ( jvmVersionMajor==1 && jvmVersionMinor>=2 ) + ) + { + jniEXTsuff = "12"; + } + + if(gljLibName==null) + gljLibName = defGljLib+jniEXTsuff; + if(glLibName==null) + glLibName = defGLFuncLib+jniEXTsuff; + if(gluLibName==null) + gluLibName = defGLUFuncLib+jniEXTsuff; + + if ( (osType==OsWindoof) && (isMicrosoftJvm) ) + { + // JDirect loads the GL libraries automatically, + // so we don't have to. + libNames = new String[4]; + libNames[0]= gljLibName; + libNames[1]= glLibName; + libNames[2]= gluLibName; + libNames[3]= defGljMSWinLib; + useMSJDirect = true; + } else { + /* For MAC, Win32+SunJVM, Unices ... + */ + libNames = new String[3]; + libNames[0]= gljLibName; + libNames[1]= glLibName; + libNames[2]= gluLibName; + useMSJDirect = false; + } + + if(isNetscapeJvm) + { + System.out.println("Netscape JVM try to get Privileges"); + try { + Class privmgr = + Class.forName("netscape.security.PrivilegeManager"); + Class[] parameterTypes = new Class[1]; + parameterTypes[0] = Class.forName("java.lang.String"); + Method m = privmgr.getMethod("enablePrivilege",parameterTypes); + Object args[] = new Object[1]; + args[0] = (Object)(new String("UniversalLinkAccess")); + m.invoke(privmgr,args); + /* + netscape.security.PrivilegeManager.enablePrivilege + ("UniversalLinkAccess"); + */ + System.out.println("Netscape-Privilege: enabled UniversalLinkAccess priv."); + } catch (Exception ex) + { + System.out.println("Not enabled Netscape-Privilege: UniversalLinkAccess priv."); + } + } + + /* load libs */ + int libNumber = 0; + String _libName = null ; + boolean libLoaded[] = new boolean[libNames.length]; + + for(libNumber=0; libNumber gl4java-glj-lib native library + * -gllib gl4java-gl-lib native library + * -glulib gl4java-glu-lib native library + * -glclass gl4java-gl-class java GLFunc implementation + * -gluclass gl4java-glu-class java GLUFunc implementation + * -info creates a GLContext and prints all avaiable information of GL/GLU and GL4Java + * -infotxt like -info, but exits straight after -info ! + * + * without any arguments, a help screen is shown + */ + public static void main( String args[] ) + { + String gljLibName = null; + String glLibName = null; + String gluLibName = null; + String glName = defGLFuncClass; + String gluName = defGLUFuncClass; + boolean info=false; + boolean exitImmediatly=false; + int i = 0; + boolean ok=true; + + if(args.length==0) + { + System.out.println("usage: java gl4java.GLContext , where options can be: "); + System.out.println(" -gljlib \t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib \t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib \t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass \t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass \t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)"); + System.out.println(" -info \t creates a GLContext and prints all avaiable information of GL/GLU and GL4Java"); + System.out.println(" -infotxt \t like -info, but exits straight after -info !"); + System.exit(0); + } + + while(args.length>i) + { + if(args[i].equals("-gljlib")) { + if(args.length>++i) gljLibName=args[i]; + } else if(args[i].equals("-gllib")) { + if(args.length>++i) glLibName=args[i]; + } else if(args[i].equals("-glulib")) { + if(args.length>++i) gluLibName=args[i]; + } else if(args[i].equals("-glclass")) { + if(args.length>++i) glName=args[i]; + } else if(args[i].equals("-gluclass")) { + if(args.length>++i) gluName=args[i]; + } else if(args[i].equals("-info")) { + info=true; + } else if(args[i].equals("-infotxt")) { + info=true; + exitImmediatly=true; + } else { + System.out.println("illegal arg "+i+": "+args[i]); + ok=false; + } + i++; + } + + GLContext.gljNativeDebug = true; + GLContext.gljClassDebug = true; + + GLFunc gl = null; + GLUFunc glu = null; + + if(GLContext.loadNativeLibraries(gljLibName, glLibName, gluLibName)) + System.out.println("native Libraries loaded succesfull"); + else { + System.out.println("native library NOT loaded complete"); + ok=false; + } + + if( (gl=GLContext.createGLFunc(glName)) !=null) + System.out.println("GLFunc implementation "+glName+" created succesfull"); + else { + System.out.println("GLFunc implementation "+glName+" not created"); + ok=false; + } + if( (glu=GLContext.createGLUFunc(gluName)) !=null) + System.out.println("GLUFunc implementation "+gluName+" created succesfull"); + else { + System.out.println("GLUFunc implementation "+gluName+" not created"); + ok=false; + } + + if( info && ok==true) { + Frame f = new Frame("GL4Java Info"); + f.setSize(10, 10); + + f.pack(); + f.setVisible(true); + + GLContext glj = new GLContext(f, gl, glu); + + Frame fInfo = glj.gljShowVersions(); + + fInfo.addWindowListener + ( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + // button exit + System.exit(0); + } + } + ); + + glj.gljDestroy(); + + if(exitImmediatly) + System.exit(0); + } + } + + public static String getJVMVendor() { return jvmVendor; } + public static boolean isNetscapeJVM() { return isNetscapeJvm; } + public static boolean isMicrosoftJVM() { return isMicrosoftJvm; } + + /** + * Used to hold the user given GLFunc implementation + */ + private GLFunc gl = null; + + /** + * Used to hold the user given GLUFunc implementation + */ + private GLUFunc glu = null; + + /** + * + * Constructor + * + * This privat constructor is for all possible + * compinations and is called from the customized + * constructors. + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _offScreenRenderer the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * @param _sharedGLContext the shared GLContext + * @param _offScrnSize the fixed offscreen pixmap size + * + */ + protected GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, boolean _offScreenRenderer, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext, + Dimension _offScrnSize + ) + { + super( ); + + _comp = comp ; // the light- or heavy component + gl = glf ; + glu = gluf ; + createOwnWindow = _createOwnWindow; + offScreenRenderer = _offScreenRenderer; + doubleBuffer=_doubleBuffer; + stereoView=_stereoView; + rgba=_rgba; + stencilBits=_stencilBits; + accumSize=_accumSize; + offScrnSize= _offScrnSize; + + this.sharedGLContext = _sharedGLContext; + if(sharedGLContext != null) + sharedGLContextNative = + (int)sharedGLContext.getNativeGLContext(); + + // fetch the heavy peer component in temporary var. comp + while(comp!=null && + (comp.getPeer() instanceof java.awt.peer.LightweightPeer) + ) + comp=comp.getParent(); + + _compHeavy = comp ; // the heavy component + + Graphics _gr = null; + + if(_compHeavy!=null) + { + if( ! _comp.isVisible() ) + setVisible(true); // use our own ... + + + _gr = _compHeavy.getGraphics(); + if(_gr==null) + System.out.println("got empty Graphics"); + } else + System.out.println("got empty Component"); + + if(_comp!=null && _gr!=null) + { + int i = 0; + do { + createGLContext(_gr); // uses _comp + if(gljIsInit()==false) + { + try + { + Thread.sleep( 100 ); + } + catch( Exception e ) + { } + } + i++; + } while(gljIsInit()==false && i<5) ; + } + + if(gljClassDebug) + { + if(gljIsInit()) + System.out.println(">>> GLContext() succeded"); + else + System.out.println(">>> GLContext() failed"); + } + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * @param _sharedGLContext the shared GLContext + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * ! WARNING ! This flag is just for testing purpose !!! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + true /* _rgba */, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * We use a visual with doubleBuffer and NO stereoView ! + * Do not force a new native window ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + true /* _doubleBuffer */, + false /* _stereoView */, + true /* _rgba */, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor Function for offscreen rendering ! + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _sharedGLContext the shared GLContext + * + * @return the created offscreen context + */ + public static final GLContext createOffScreenCtx + ( Component comp, GLFunc glf, GLUFunc gluf, + boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext + ) + { + return new GLContext(comp, glf, gluf, + false /* _createOwnWindow */, + true /* offscreen renderer */, + false /* _doubleBuffer */, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + null + ); + } + + /** + * + * Constructor Function for offscreen rendering ! + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _sharedGLContext the shared GLContext + * @param _offScrnSize the fixed offscreen pixmap size + * + * @return the created offscreen context + */ + public static final GLContext createOffScreenCtx + ( Component comp, GLFunc glf, GLUFunc gluf, + boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext, + Dimension _offScrnSize + ) + { + return new GLContext(comp, glf, gluf, + false /* _createOwnWindow */, + true /* offscreen renderer */, + false /* _doubleBuffer */, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + _offScrnSize + ); + } + + /** + * Used to set the user given GLFunc implementation + */ + public final void setGLFunc(GLFunc _gl) { gl = _gl; } + + /** + * Used to set the user given GLUFunc implementation + */ + public final void setGLUFunc(GLUFunc _glu) { glu = _glu; } + + /** + * Used to return the user given GLFunc implementation + */ + public final GLFunc getGLFunc() { return gl; } + + /** + * Used to return the user given GLUFunc implementation + */ + public final GLUFunc getGLUFunc() { return glu; } + + /** + * Support of loading a vendors GLFunc implementation + * + * Try to load the Class, if succesfull we do return the instance of it. + * Else null is returned ! + * + * The Class-Name is: "GL4Java." + vendorClass + ".class" ! + * + * @param vendorClass The name of the GLFunc implementation. + * If vendorSuffix==null, the default implementation + * "GLFuncJauJNI" (-> GL4Java.GLFuncJauJNI.class ) + * will be used ! + * + * @return GLFunc, the implementation's instance if exists + * and valid, or null + * + * @see GLContext#defGLFuncClass + */ + public static final GLFunc createGLFunc(String vendorClass) + { + String access_name = "gl4java."; + GLFunc gl = null; + Object clazz = null; + + if(vendorClass==null) + { + vendorClass = defGLFuncClass ; + } + + String clazzName = access_name + vendorClass ; + + try { + clazz = Class.forName(clazzName).newInstance(); + } catch (Exception ex) { + // thats ok :-) + System.out.println("could not create instance of: "+ clazzName); + } + if(clazz !=null && (clazz instanceof GLFunc)) + gl = (GLFunc) clazz; + else + System.out.println("Not a GLFunc implementation: "+ clazzName); + + return gl; + } + + /** + * Support of loading a vendors GLUFunc implementation + * + * Try to load the Class, if succesfull we do return the instance of it. + * Else null is returned ! + * + * The Class-Name is: "GL4Java." + vendorClass + ".class" ! + * + * @param vendorClass The name of the GLUFunc implementation. + * If vendorSuffix==null, the default implementation + * "GLUFuncJauJNI" (-> GL4Java.GLUFuncJauJNI.class ) + * will be used ! + * + * @return GLUFunc, the implementation's instance if exists + * and valid, or null + * + * @see GLContext#defGLUFuncClass + */ + public static final GLUFunc createGLUFunc(String vendorClass) + { + String access_name = "gl4java."; + GLUFunc glu = null; + Object clazz = null; + + if(vendorClass==null) + { + vendorClass = defGLUFuncClass ; + } + + + String clazzName = access_name + vendorClass ; + + try { + clazz = Class.forName(clazzName).newInstance(); + } catch (Exception ex) { + // thats ok :-) + System.out.println("could not create instance of: "+ clazzName); + } + if(clazz!=null && (clazz instanceof GLUFunc)) + glu = (GLUFunc) clazz; + else + System.out.println("Not a GLUFunc implementation: "+ clazzName); + + + return glu; + } + + /** + * + * Own setVisible + * This one set's us visible - and wait's for that result ! + * + * @param visible boolean: visible==true, hide==false + * @return void + */ + public void setVisible( boolean visible ) + { + int i= 0; + + _comp.setVisible( visible ); + + while( _comp.isVisible() != visible && i<5) + { + _comp.setVisible( visible ); + + try + { + Thread.sleep( 100 ); + } + catch( Exception e ) + { + System.out.println( "GLContext:setVisible: Error - " + e ); + } + i++; + } + if(i>=5) + System.out.println( "GLContext:setVisible: Error, could not set to "+visible); + } + + /** + * + * createGLContext gets the window handle and calls gljInit, + * so the gl-context will be initialised here. + * + * this method will be invoked by the constructor + * + * this method is left public - this time, + * to allow the user to to it again later - if it was not succesfull ! + * + * @param g the graphics reference, + * where we will get the native window handle from. + * + * @return void + * + * @see GLContext#GLContext + */ + public final void createGLContext(Graphics g) + { + String access_name = "gl4java.jau.awt."; + WinHandleAccess win_access = null; + + try { + if(gljClassDebug) + System.out.println(">>> createGLContext"); + + if(pData == 0) + { + if ( useMSJDirect ) + { + if(gljClassDebug) + System.out.println("using MSJDirect ..."); + + win_access = (WinHandleAccess) + Class.forName(access_name + "windows.MSWin32HandleAccess").newInstance(); + /* _comp should be a subclass of Canvas, and its parent + class should be of type Panel, Frame or Window. If not, + this all falls apart. */ + + /* This part is now rewritten, + to respect direkt Windows (Frames and Dialogs) + and Applets .. */ + + Component ob = _comp; + + while ( (ob instanceof Window)==false && + (ob instanceof Applet)==false + ) + { + ob = ob.getParent(); + } + + containerWindow = (Container)ob; + + /* refetch the Graphics component */ + g = ob.getGraphics(); + if(g==null) + System.out.println("GL4Java-MSJVM: got empty Graphics"); + + pData = (int)win_access.getWinHandle(ob,g); + + if (pData != 0) + { + Point p1; + try + { + p1 = _comp.getLocationOnScreen(); + } + catch (Exception e) + { + p1 = _comp.getLocation(); + Point p2 = containerWindow.getLocation(); + p1.x += p2.x; + p1.y += p2.y; + Insets is = containerWindow.getInsets(); + p1.x += is.left; + p1.y += is.top; + } + Rectangle r = _comp.getBounds(); + createwinx = p1.x; + createwiny = p1.y; + createwinw = r.width; + createwinh = r.height; + windowHandle = 0; + threadRunning = true; + destroyWindow = false; + Thread th = new Thread(this); + th.start(); + while ( (windowHandle == 0) && (threadRunning) ) + { + try + { + Thread.currentThread().sleep(100); + } + catch( Exception e ) + { } + } + } + } else if(osType==OsWindoof) + { + win_access = (WinHandleAccess) + Class.forName(access_name + "windows.Win32HandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + else if(osType==OsMac) + { + win_access = (WinHandleAccess) + Class.forName(access_name + "macintosh.MacHandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + else /* X11 */ + { + win_access = (WinHandleAccess) + Class.forName(access_name + "motif.X11HandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + } + + if(offScrnSize!=null) + { + createwinw = offScrnSize.width; + createwinh = offScrnSize.height; + } else { + Rectangle r = _comp.getBounds(); + createwinw = r.width; + createwinh = r.height; + } + + /* try to establish a context to OpenGL */ + try + { + gljInit(); + } + catch( GL4JavaInitException e ) + { + System.out.println( "can't create a GL context\n"); + } + + } catch (Exception e) { + System.out.println( "An exception is thrown, while creating a GL context\n"); + System.out.println(e); + e.printStackTrace(); + } + } + + /* glj* stuff */ + + /** + * + * Initializes the gl-context. + * gljInit is called by createGLContext (which is calles by the first paint)! + * + * Also gljInit will call the init method after GL initialisation, + * so the user can override ´init´ to initialize his own stuff ! + * + * @return void + * @exception GL4Java.GL4JavaInitException + * this class throws an exception + * if the native call to create a OpenGL context failed. + * @see GLContext#createGLContext + * @see gl4java.awt.GLCanvas#paint + * @see gl4java.awt.GLCanvas#init + */ + protected final synchronized void gljInit() + throws GL4JavaInitException + { + if( libsLoaded==false ) return ; + + if(pData==0 && !offScreenRenderer) + { + System.out.println("could not open a GL widget -- Win CONTEXT"); + throw new GL4JavaInitException (); + } + + if(gljClassDebug) + System.out.println(">>> gljInit"); + + if( openOpenGLNative() == false ) + { + if ( useMSJDirect ) + { + destroyWindow = true; + while (threadRunning) + { + try + { + Thread.currentThread().sleep(100); + } + catch( Exception e ) + { } + } + pData = 0; + windowHandle = 0; + } + System.out.println("could not open a GL widget -- GL CONTEXT"); + throw new GL4JavaInitException (); + } else { + isInitialized = true; + } + } + + /** + * For MSJVM Only ! + * + * This functions fetches the window-handle within a special thread ! + */ + public void run() + { + if ( !useMSJDirect ) + { + System.err.println("GL4Java-MSJVM-Run: INTERNAL ERROR"); + System.exit(0); + } + + pData = gl4java.system.GljMSJDirect.createOGLWindowNative( + pData, + createwinx,createwiny, + createwinw,createwinh); + if (pData != 0) + { + windowHandle = pData; + while (!destroyWindow) + { + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + try + { + Thread.currentThread().sleep(10); + } + catch( Exception e ) + { } + } + destroyWindow = false; + gl4java.system.GljMSJDirect.destroyOGLWindowNative( + windowHandle); + windowHandle = 0; + pData = 0; + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + } + threadRunning = false; + } + + /** + * + * Checks if the gl-context is Initializes + * If returns true, + * gljInit is allready called and a valid gl-context is achieved. + * + * No glMakeCurrent is done - + * like gljMakeCurrent (important for more gl-context) ! + * + *

+ * + * The user can use this method to check if he can start rendering + * and to be sure his initialisation (init) is done ! + * + *

+ * + * If you use gl4java.awt.GLCanvas, you should use the cvsIsInit + * method ! + *

+ * + * @return boolean + * @see GLContext#gljInit + * @see gl4java.awt.GLCanvas#cvsIsInit + */ + public final boolean gljIsInit() + { + return isInitialized; + } + + /** + * Resizes the gl-viewport + * + * Should be called, if the component is resized. + * The user should take advantage of this functionality. + * + * Be sure to resize not within the event-method of the + * ComponentHandler, you better resize while normal painting. + * This can be done while using a boolean flag ;-) + * + * Look at GLComponent ! + */ + public final void gljResize(int width, int height) + { + if ( ! isInitialized || !glEnabled ) return; + + if(offScreenRenderer) + { + //JAU: TODO + return; + } + + if ( useMSJDirect ) + { + try + { + Point p = _comp.getLocationOnScreen(); + gl4java.system.GljMSJDirect.moveOGLWindowNative( + windowHandle,p.x,p.y,width,height); + } + catch (Exception e) + { } + } + else + gljResizeNative( createOwnWindow, + displayHandle, windowHandle, + width,height); + } + + private final native void gljResizeNative( boolean isOwnWindow, + int disp, int thisWin, + int width, int height ); + + /** + * native C function to open the OpenGLwidget + */ + protected final native boolean openOpenGLNative(); + + /** + * native C function to check the gl types. + * At this time, all GL* types will be checked if they fit's + * in the used java JNI types. + * + * this checks is allready performed, while the GL context is + * fetched with gljInit ! + * + * BUT we used this function, to perform a check without an + * X11-connection to our AIX host ;-)) + * So a call to this function is not needed ! + */ + public static final boolean gljCheckGLTypes() + { + return gljCheckGLTypesNative(); + } + + private static final native boolean gljCheckGLTypesNative(); + + public final boolean gljCheckGL() + { + int ec = gl.glGetError(); + + if(ec!=GLFunc.GL_NO_ERROR) + { + String errStr = glu.gluErrorString(ec); + + try + { + throw new Exception(); + } + catch (Exception e) + { + System.out.println("GL ERROR : "+errStr); + System.out.println("GL ERROR : "+ec+" == 0x"+Integer.toHexString(ec)); + e.printStackTrace(); + System.out.println(); + System.out.flush(); + } + + return false; + } + return true; + } + + /** + * + * gljMakeCurrent checks whether GL4Java is initializes + * AND makes the GL-Context current for this thread. + * + * It's more save to use ´gljMakeCurrent´, instead of + * ´gljMakeCurrentNative´, because we do check if GL is initalised ! + * + * @return boolean + */ + public final boolean gljMakeCurrent() + { + if ( ! isInitialized || !glEnabled ) + return false; + + return gljMakeCurrentNative( displayHandle, + windowHandle, + glContext); + } + + + /** + * + * gljMakeCurrent checks whether GL4Java is initializes + * AND makes the GL-Context current for this thread. + * + * It's more save to use ´gljMakeCurrent´, instead of + * ´gljMakeCurrentNative´, because we do check if GL is initalised ! + * + * @param freeContextFirst is obsolete ! + * + * @return boolean + * + * @deprecated The argument freeContextFirst is obsolete ! + */ + public final boolean gljMakeCurrent(boolean freeContextFirst) + { + if ( ! isInitialized || !glEnabled ) + return false; + + return gljMakeCurrentNative( displayHandle, + windowHandle, + glContext); + } + + private static final native boolean gljMakeCurrentNative( + int disp, + int thisWin, + int glContext); + + /** + * + * gljGetCurrentContext fetches the current native + * GL-Context, which is attached to this _native_ thread ! + * + * @return int + */ + public static final native int gljGetCurrentContext(); + + /** + * + * gljDestroy free´s AND destroy´s the GL Context + * + * This function should be called when removing + * a GLContext !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @return void + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljSwap + */ + public final synchronized boolean gljDestroy() + { + boolean result = true; + + if (!gljDestroyNative()) + result = false; + + windowHandle = 0; + glContext = 0; + pixmapHandle = 0; + + + if ( useMSJDirect ) + { + destroyWindow = false; + gl4java.system.GljMSJDirect.destroyOGLWindowNative( pData ); + windowHandle = 0; + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + } + + pData = 0; + + return result; + } + + private final native boolean gljDestroyNative(); + + /** + * + * gljFree free´s the GL Context + * + * This could be called after at last in your display function, + * if you have GC problems .... + * + * @return void + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljSwap + * @see gl4java.awt.GLCanvas#sDisplay + */ + public final boolean gljFree() + { + if ( ! isInitialized ) return false; + + return gljFreeNative ( displayHandle, + windowHandle, + glContext); + } + + private static final native boolean gljFreeNative( int disp, + int thisWin, + int glContext ); + + /** + * swap method are for double buffering + */ + public final boolean gljSwap() + { + if ( ! isInitialized ) return false; + + return gljSwapNative( displayHandle, + windowHandle, + glContext, + doubleBuffer); + } + + private static final native boolean gljSwapNative( int disp, + int thisWin, + int glContext, + boolean doubleBuffer ); + + /** + * This function enables, disables the GL-Context ! + * If false is given, the openGL renderer/context is + * disabled and disconected (gljFree is called, if initialized) ! + * + * If disabled, gljMakeCurrent returns always false ! + * + * @return boolean + * + * @see GLContext#gljIsEnabled + * @see GLContext#gljMakeCurrent + */ + public void setEnabled(boolean b) + { + glEnabled = b; + if ( b==false && isInitialized ) + gljFree(); + } + + /** + * This function queries, if the GL-Context is enabled ! + * + * @return boolean + * + * @see GLContext#setEnabled + * @see GLContext#gljMakeCurrent + */ + public boolean isEnabled() + { + return glEnabled; + } + + /** + * This functions checks the existence of + * the GL functions ! + */ + public final static native boolean gljTestGLProc + ( String name, boolean verbose ); + + /** + * This functions reads the pixel from the GL frame + * and puts it into the pixelDest array, + * while converting them correctly to the AWT pixel format, + * using GL_RGB[A] and BufferedImage.TYPE_INT[A]RGB ! + */ + public final static native void gljReadPixelGL2AWT ( + int x, int y, int width, int height, + int format, int type, int bufferName, + byte[] pixelGL, int[] pixelDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + * + * This functions reads the pixel from the GL frame + * and puts it into the pixelDest array, + * while using hardware correct AWT and GL pixel format, + * using GL_BGR[A]_EXT and BufferedImage.TYPE_[34]BYTE_[A]BGR ! + * + * ATTENTION: This functions runs only if hardware supports this, + * e.g. on Win32 platforms !!! + */ + public final static native void gljReadPixelGL2AWT ( + int x, int y, int width, int height, + int format, int type, int bufferName, + byte[] pixelGLDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + */ + public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, byte[] pixelDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + */ + public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, int[] pixelDest); + + /** + * native C function to achieve the native lib vendor ! + * + * now it is possible to check the native-lib at runtime ! + */ + public final static String gljGetNativeLibVendor() + { + return gljGetNativeLibVendorNative(); + } + + private final static native String gljGetNativeLibVendorNative(); + + /** + * native C function to achieve the native lib version ! + * + * now it is possible to check the native-lib at runtime ! + */ + public final static String gljGetNativeLibVersion() + { + return gljGetNativeLibVersionNative(); + } + + private final static native String gljGetNativeLibVersionNative(); + + /** + * function to achieve the java-class version ! + * + * now it is possible to check the java-class at runtime ! + */ + public final static String gljGetClassVersion() + { return version; } + + /** + * function to achieve the java-class vendor ! + * + * now it is possible to check the java-class at runtime ! + */ + public final static String gljGetClassVendor() + { return "Jausoft - Sven Goethel Software Development"; } + + /** + * function to achieve complete version info + * + * Be sure that the native library must be loaded ! + */ + public final String gljGetVersions() + { + return gljGetVersions(false); + } + + public final String gljGetVersions(boolean verbose) + { + if(libsLoaded==false || gl==null || glu==null || !gljIsInit()) + return null; + + String info1= "GL4Java - LGPL-Version" + "\n" + + "-------------------------------------------------\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLContext \n" + + " : Version: "+gljGetClassVersion() + "\n" + + " Vendor : "+gljGetClassVendor() + "\n" + + "Native-Library : GL4Java.GLContext \n" + + " Version: "+gljGetNativeLibVersion()+"\n" + + " Vendor : "+gljGetNativeLibVendor() +"\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLFunc impl. \n" + + " : Version: "+gl.getClassVersion() + "\n" + + " Vendor : "+gl.getClassVendor() + "\n" + + "Native-Library : GL4Java.GLFunc impl. \n" + + " Version: "+gl.getNativeVersion() + "\n" + + " Vendor : "+gl.getNativeVendor() + "\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLUFunc impl. \n" + + " : Version: "+glu.getClassVersion() + "\n" + + " Vendor : "+glu.getClassVendor() + "\n" + + "Native-Library : GL4Java.GLUFunc impl. \n" + + " Version: "+glu.getNativeVersion() + "\n" + + " Vendor : "+glu.getNativeVendor() + "\n" + + "-------------------------------------------------\n" + + "\n" ; + + String glVen = gl.glGetString(GLFunc.GL_VENDOR); + String glRen = gl.glGetString(GLFunc.GL_RENDERER); + String glVer = gl.glGetString(GLFunc.GL_VERSION); + String glExt = gl.glGetString(GLFunc.GL_EXTENSIONS); + String gluVer = glu.gluGetString(GLUFunc.GLU_VERSION); + String gluExt = glu.gluGetString(GLUFunc.GLU_EXTENSIONS); + + String info2= "OpenGL - Versions \n" + + "-----------------------------------------------\n" + + "GL VENDOR: "+glVen+"\n"+ + "GL RENDERER: "+glRen+"\n"+ + "GL VERSION: "+glVer+"\n"+ + "GL EXTENSIONS: "+glExt+"\n"+ + "GLU VERSION: "+gluVer+"\n"+ + "GLU EXTENSIONS: "+gluExt+"\n"+"\n" ; + + String info3= "OpenGL - Function Test ("+ + GLFunc.GL_PROC_NAMES.length +" Functions) \n" + + "-----------------------------------------------\n"; + + if(verbose) + { + System.out.println(info1); + System.out.println(info2); + System.out.println(info3); + } + + String h; + String tmp; + + for(int i=0; i + extern void glClearIndex ( GLfloat c ) ; + * + */ + public void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * 

 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClear ( GLbitfield mask ) ;
+ *
+ */ + public void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexMask ( GLuint mask ) ;
+ *
+ */ + public void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ *
+ */ + public void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ *
+ */ + public void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ *
+ */ + public void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLogicOp ( GLenum opcode ) ;
+ *
+ */ + public void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCullFace ( GLenum mode ) ;
+ *
+ */ + public void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrontFace ( GLenum mode ) ;
+ *
+ */ + public void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointSize ( GLfloat size ) ;
+ *
+ */ + public void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineWidth ( GLfloat width ) ;
+ *
+ */ + public void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ *
+ */ + public void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ *
+ */ + public void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ *
+ */ + public void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ *
+ */ + public void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ *
+ */ + public void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ *
+ */ + public void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ *
+ */ + public void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ *
+ */ + public void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ *
+ */ + public void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ *
+ */ + public void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadBuffer ( GLenum mode ) ;
+ *
+ */ + public void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnable ( GLenum cap ) ;
+ *
+ */ + public void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisable ( GLenum cap ) ;
+ *
+ */ + public void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ *
+ */ + public boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnableClientState ( GLenum cap ) ;
+ *
+ */ + public void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisableClientState ( GLenum cap ) ;
+ *
+ */ + public void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ *
+ */ + public void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ *
+ */ + public void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ *
+ */ + public void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopAttrib ( void ) ;
+ *
+ */ + public void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ *
+ */ + public void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopClientAttrib ( void ) ;
+ *
+ */ + public void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ *
+ */ + public int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLenum glGetError ( void ) ;
+ *
+ */ + public int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFinish ( void ) ;
+ *
+ */ + public void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFlush ( void ) ;
+ *
+ */ + public void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ *
+ */ + public void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearDepth ( GLclampd depth ) ;
+ *
+ */ + public void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthFunc ( GLenum func ) ;
+ *
+ */ + public void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthMask ( GLboolean flag ) ;
+ *
+ */ + public void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ *
+ */ + public void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ *
+ */ + public void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMatrixMode ( GLenum mode ) ;
+ *
+ */ + public void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushMatrix ( void ) ;
+ *
+ */ + public void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopMatrix ( void ) ;
+ *
+ */ + public void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadIdentity ( void ) ;
+ *
+ */ + public void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsList ( GLuint list ) ;
+ *
+ */ + public boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ *
+ */ + public void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ *
+ */ + public int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ *
+ */ + public void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEndList ( void ) ;
+ *
+ */ + public void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallList ( GLuint list ) ;
+ *
+ */ + public void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ *
+ */ + public void glCallLists ( + int n, + int type, + byte[] lists + ) ; + public void glCallLists ( + int n, + int type, + short[] lists + ) ; + public void glCallLists ( + int n, + int type, + int[] lists + ) ; + public void glCallLists ( + int n, + int type, + float[] lists + ) ; + public void glCallLists ( + int n, + int type, + double[] lists + ) ; + public void glCallLists ( + int n, + int type, + boolean[] lists + ) ; + public void glCallLists ( + int n, + int type, + long[] lists + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glListBase ( GLuint base ) ;
+ *
+ */ + public void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBegin ( GLenum mode ) ;
+ *
+ */ + public void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnd ( void ) ;
+ *
+ */ + public void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ *
+ */ + public void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ *
+ */ + public void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ *
+ */ + public void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2iv ( const GLint * v ) ;
+ *
+ */ + public void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ *
+ */ + public void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ *
+ */ + public void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ *
+ */ + public void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3iv ( const GLint * v ) ;
+ *
+ */ + public void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ *
+ */ + public void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ *
+ */ + public void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ *
+ */ + public void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4iv ( const GLint * v ) ;
+ *
+ */ + public void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ *
+ */ + public void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ *
+ */ + public void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ *
+ */ + public void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ *
+ */ + public void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ *
+ */ + public void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ *
+ */ + public void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ *
+ */ + public void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ *
+ */ + public void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ *
+ */ + public void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3iv ( const GLint * v ) ;
+ *
+ */ + public void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ *
+ */ + public void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexd ( GLdouble c ) ;
+ *
+ */ + public void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexf ( GLfloat c ) ;
+ *
+ */ + public void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexi ( GLint c ) ;
+ *
+ */ + public void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexs ( GLshort c ) ;
+ *
+ */ + public void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexub ( GLubyte c ) ;
+ *
+ */ + public void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ *
+ */ + public void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ *
+ */ + public void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexiv ( const GLint * c ) ;
+ *
+ */ + public void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexsv ( const GLshort * c ) ;
+ *
+ */ + public void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ *
+ */ + public void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ *
+ */ + public void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ *
+ */ + public void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ *
+ */ + public void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ *
+ */ + public void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ *
+ */ + public void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ *
+ */ + public void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ *
+ */ + public void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ *
+ */ + public void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ *
+ */ + public void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ *
+ */ + public void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ *
+ */ + public void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ *
+ */ + public void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ *
+ */ + public void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ *
+ */ + public void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ *
+ */ + public void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ *
+ */ + public void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ *
+ */ + public void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ *
+ */ + public void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3iv ( const GLint * v ) ;
+ *
+ */ + public void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3sv ( const GLshort * v ) ;
+ *
+ */ + public void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ *
+ */ + public void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ *
+ */ + public void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3usv ( const GLushort * v ) ;
+ *
+ */ + public void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ *
+ */ + public void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ *
+ */ + public void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ *
+ */ + public void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4iv ( const GLint * v ) ;
+ *
+ */ + public void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4sv ( const GLshort * v ) ;
+ *
+ */ + public void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ *
+ */ + public void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ *
+ */ + public void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4usv ( const GLushort * v ) ;
+ *
+ */ + public void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ *
+ */ + public void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ *
+ */ + public void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1i ( GLint s ) ;
+ *
+ */ + public void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1s ( GLshort s ) ;
+ *
+ */ + public void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ *
+ */ + public void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ *
+ */ + public void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ *
+ */ + public void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ *
+ */ + public void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ *
+ */ + public void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ *
+ */ + public void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ *
+ */ + public void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ *
+ */ + public void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ *
+ */ + public void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ *
+ */ + public void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ *
+ */ + public void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ *
+ */ + public void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ *
+ */ + public void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ *
+ */ + public void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ *
+ */ + public void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ *
+ */ + public void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ *
+ */ + public void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ *
+ */ + public void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ *
+ */ + public void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ *
+ */ + public void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ *
+ */ + public void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ *
+ */ + public void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ *
+ */ + public void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ *
+ */ + public void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ *
+ */ + public void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ *
+ */ + public void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ *
+ */ + public void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ *
+ */ + public void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ *
+ */ + public void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ *
+ */ + public void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ *
+ */ + public void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ *
+ */ + public void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ *
+ */ + public void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ *
+ */ + public void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ *
+ */ + public void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ *
+ */ + public void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ *
+ */ + public void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ *
+ */ + public void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ *
+ */ + public void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ *
+ */ + public void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ *
+ */ + public void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ *
+ */ + public void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glVertexPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public void glVertexPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glNormalPointer ( + int type, + int stride, + byte[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + short[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + int[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + float[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + double[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public void glNormalPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glColorPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public void glColorPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glIndexPointer ( + int type, + int stride, + byte[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + short[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + int[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + float[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + double[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public void glIndexPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glTexCoordPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public void glTexCoordPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public void glEdgeFlagPointer ( + int stride, + byte[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + short[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + int[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + float[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + double[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + boolean[] ptr + ) ; + public void glEdgeFlagPointer ( + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ *
+ */ + public void glGetPointerv ( + int pname, + byte[][] params + ) ; + public void glGetPointerv ( + int pname, + short[][] params + ) ; + public void glGetPointerv ( + int pname, + int[][] params + ) ; + public void glGetPointerv ( + int pname, + float[][] params + ) ; + public void glGetPointerv ( + int pname, + double[][] params + ) ; + public void glGetPointerv ( + int pname, + boolean[][] params + ) ; + public void glGetPointerv ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElement ( GLint i ) ;
+ *
+ */ + public void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public void glDrawElements ( + int mode, + int count, + int type, + byte[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + short[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + int[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + float[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + double[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + boolean[] indices + ) ; + public void glDrawElements ( + int mode, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ *
+ */ + public void glInterleavedArrays ( + int format, + int stride, + byte[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + short[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + int[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + float[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + double[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + boolean[] pointer + ) ; + public void glInterleavedArrays ( + int format, + int stride, + long[] pointer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glShadeModel ( GLenum mode ) ;
+ *
+ */ + public void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ *
+ */ + public void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ *
+ */ + public void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ *
+ */ + public void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ *
+ */ + public void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ *
+ */ + public void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ *
+ */ + public void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ *
+ */ + public void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ *
+ */ + public void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ *
+ */ + public void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ *
+ */ + public void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ *
+ */ + public void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ *
+ */ + public void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ *
+ */ + public void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ *
+ */ + public void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glDrawPixels ( + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public void glDrawPixels ( + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ *
+ */ + public void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ *
+ */ + public void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilMask ( GLuint mask ) ;
+ *
+ */ + public void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ *
+ */ + public void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearStencil ( GLint s ) ;
+ *
+ */ + public void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ *
+ */ + public void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ *
+ */ + public void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ *
+ */ + public void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ *
+ */ + public void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + byte[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + short[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + int[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + float[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + double[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + boolean[] pixels + ) ; + public void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + byte[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + short[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + int[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + float[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + double[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + boolean[] pixels + ) ; + public void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public void glGetTexImage ( + int target, + int level, + int format, + int type, + byte[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + short[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + int[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + float[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + double[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + boolean[] pixels + ) ; + public void glGetTexImage ( + int target, + int level, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ *
+ */ + public void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ *
+ */ + public boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + byte[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + short[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + int[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + float[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + double[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + boolean[] pixels + ) ; + public void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ *
+ */ + public void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ *
+ */ + public void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ *
+ */ + public void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ *
+ */ + public void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ *
+ */ + public void glMap2d ( + int target, + double u1, + double u2, + int ustride, + int uorder, + double v1, + double v2, + int vstride, + int vorder, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ *
+ */ + public void glMap2f ( + int target, + float u1, + float u2, + int ustride, + int uorder, + float v1, + float v2, + int vstride, + int vorder, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ *
+ */ + public void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ *
+ */ + public void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ *
+ */ + public void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ *
+ */ + public void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ *
+ */ + public void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ *
+ */ + public void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ *
+ */ + public void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ *
+ */ + public void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ *
+ */ + public void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ *
+ */ + public void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ *
+ */ + public void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ *
+ */ + public void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ *
+ */ + public void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ *
+ */ + public void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ *
+ */ + public void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint1 ( GLint i ) ;
+ *
+ */ + public void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ *
+ */ + public void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ *
+ */ + public void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ *
+ */ + public void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ *
+ */ + public void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ *
+ */ + public void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPassThrough ( GLfloat token ) ;
+ *
+ */ + public void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ *
+ */ + public void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInitNames ( void ) ;
+ *
+ */ + public void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadName ( GLuint name ) ;
+ *
+ */ + public void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushName ( GLuint name ) ;
+ *
+ */ + public void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopName ( void ) ;
+ *
+ */ + public void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + byte[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + short[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + int[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + float[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + double[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + boolean[] indices + ) ; + public void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glCopyTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public void glGetColorTable ( + int target, + int format, + int type, + byte[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + short[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + int[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + float[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + double[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + boolean[] table + ) ; + public void glGetColorTable ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquation ( GLenum mode ) ;
+ *
+ */ + public void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetHistogram ( GLenum target ) ;
+ *
+ */ + public void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ *
+ */ + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + byte[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + short[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + int[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + float[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + double[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + boolean[] values + ) ; + public void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetMinmax ( GLenum target ) ;
+ *
+ */ + public void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ *
+ */ + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + byte[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + short[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + int[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + float[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + double[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + boolean[] values + ) ; + public void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + short[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + int[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + float[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + double[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] image + ) ; + public void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] image + ) ; + public void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ *
+ */ + public void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ *
+ */ + public void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ *
+ */ + public void glGetConvolutionFilter ( + int target, + int format, + int type, + byte[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + short[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + int[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + float[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + double[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + boolean[] image + ) ; + public void glGetConvolutionFilter ( + int target, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ *
+ */ + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] row, + byte[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] row, + short[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] row, + int[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] row, + float[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] row, + double[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] row, + boolean[] column + ) ; + public void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] row, + long[] column + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ *
+ */ + public void glGetSeparableFilter ( + int target, + int format, + int type, + byte[] row, + byte[] column, + byte[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + short[] row, + short[] column, + short[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + int[] row, + int[] column, + int[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + float[] row, + float[] column, + float[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + double[] row, + double[] column, + double[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + boolean[] row, + boolean[] column, + boolean[] span + ) ; + public void glGetSeparableFilter ( + int target, + int format, + int type, + long[] row, + long[] column, + long[] span + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ *
+ */ + public void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public void glCopyTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ *
+ */ + public void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ *
+ */ + public boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public void glNormalPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public void glNormalPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public void glIndexPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public void glIndexPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ *
+ */ + public void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ *
+ */ + public void glGetPointervEXT ( + int pname, + byte[][] params + ) ; + public void glGetPointervEXT ( + int pname, + short[][] params + ) ; + public void glGetPointervEXT ( + int pname, + int[][] params + ) ; + public void glGetPointervEXT ( + int pname, + float[][] params + ) ; + public void glGetPointervEXT ( + int pname, + double[][] params + ) ; + public void glGetPointervEXT ( + int pname, + boolean[][] params + ) ; + public void glGetPointervEXT ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElementEXT ( GLint i ) ;
+ *
+ */ + public void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ *
+ */ + public void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public void glGetColorTableEXT ( + int target, + int format, + int type, + byte[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + short[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + int[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + float[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + double[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + boolean[] table + ) ; + public void glGetColorTableEXT ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ *
+ */ + public void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glUnlockArraysEXT ( void ) ;
+ *
+ */ + public void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ *
+ */ + public void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ *
+ */ + public void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ *
+ */ + public void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ *
+ */ + public void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ *
+ */ + public void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ *
+ */ + public void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ *
+ */ + public void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ *
+ */ + public void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ *
+ */ + public void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public void glMultiTexCoord4svARB ( + int target, + short[] v + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLFuncJauJNI.java b/gl4java/GLFuncJauJNI.java new file mode 100644 index 0000000..0293576 --- /dev/null +++ b/gl4java/GLFuncJauJNI.java @@ -0,0 +1,6997 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLFuncJauJNI.java + */ + + +package gl4java; + +/** + * The default implementation class for OpenGL native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public class GLFuncJauJNI + implements GLFunc +{ + + + +public final native String glGetString ( int name ) ; + +public final native String getNativeVendor ( ) ; +public final native String getNativeVersion ( ) ; + +public final String getClassVendor ( ) +{ return "Jausoft - Sven Goethel Software Development"; } + +public final String getClassVersion ( ) +{ return "2.4.1.0"; } + + + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: gl-proto-auto.orig . . . + * Destination-Class: gl4java_GLFuncJauJNI ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearIndex ( GLfloat c ) ;
+ *
+ */ + public final native void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public final native void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClear ( GLbitfield mask ) ;
+ *
+ */ + public final native void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexMask ( GLuint mask ) ;
+ *
+ */ + public final native void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ *
+ */ + public final native void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ *
+ */ + public final native void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ *
+ */ + public final native void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLogicOp ( GLenum opcode ) ;
+ *
+ */ + public final native void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCullFace ( GLenum mode ) ;
+ *
+ */ + public final native void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrontFace ( GLenum mode ) ;
+ *
+ */ + public final native void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointSize ( GLfloat size ) ;
+ *
+ */ + public final native void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineWidth ( GLfloat width ) ;
+ *
+ */ + public final native void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ *
+ */ + public final native void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ *
+ */ + public final native void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ *
+ */ + public final native void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ *
+ */ + public final native void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ *
+ */ + public final native void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ *
+ */ + public final native void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ *
+ */ + public final native void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ *
+ */ + public final native void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ *
+ */ + public final native void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ *
+ */ + public final native void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadBuffer ( GLenum mode ) ;
+ *
+ */ + public final native void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnable ( GLenum cap ) ;
+ *
+ */ + public final native void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisable ( GLenum cap ) ;
+ *
+ */ + public final native void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ *
+ */ + public final native boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnableClientState ( GLenum cap ) ;
+ *
+ */ + public final native void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisableClientState ( GLenum cap ) ;
+ *
+ */ + public final native void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ *
+ */ + public final native void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ *
+ */ + public final native void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ *
+ */ + public final native void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopAttrib ( void ) ;
+ *
+ */ + public final native void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ *
+ */ + public final native void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopClientAttrib ( void ) ;
+ *
+ */ + public final native void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ *
+ */ + public final native int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLenum glGetError ( void ) ;
+ *
+ */ + public final native int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFinish ( void ) ;
+ *
+ */ + public final native void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFlush ( void ) ;
+ *
+ */ + public final native void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ *
+ */ + public final native void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearDepth ( GLclampd depth ) ;
+ *
+ */ + public final native void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthFunc ( GLenum func ) ;
+ *
+ */ + public final native void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthMask ( GLboolean flag ) ;
+ *
+ */ + public final native void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ *
+ */ + public final native void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public final native void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ *
+ */ + public final native void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMatrixMode ( GLenum mode ) ;
+ *
+ */ + public final native void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public final native void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public final native void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushMatrix ( void ) ;
+ *
+ */ + public final native void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopMatrix ( void ) ;
+ *
+ */ + public final native void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadIdentity ( void ) ;
+ *
+ */ + public final native void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public final native void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public final native void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public final native void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public final native void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public final native void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public final native void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public final native void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsList ( GLuint list ) ;
+ *
+ */ + public final native boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ *
+ */ + public final native void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ *
+ */ + public final native int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ *
+ */ + public final native void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEndList ( void ) ;
+ *
+ */ + public final native void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallList ( GLuint list ) ;
+ *
+ */ + public final native void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ *
+ */ + public final native void glCallLists ( + int n, + int type, + byte[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + short[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + int[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + float[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + double[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + boolean[] lists + ) ; + public final native void glCallLists ( + int n, + int type, + long[] lists + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glListBase ( GLuint base ) ;
+ *
+ */ + public final native void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBegin ( GLenum mode ) ;
+ *
+ */ + public final native void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnd ( void ) ;
+ *
+ */ + public final native void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public final native void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public final native void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ *
+ */ + public final native void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public final native void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public final native void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public final native void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public final native void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public final native void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public final native void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public final native void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public final native void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2iv ( const GLint * v ) ;
+ *
+ */ + public final native void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3iv ( const GLint * v ) ;
+ *
+ */ + public final native void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4iv ( const GLint * v ) ;
+ *
+ */ + public final native void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ *
+ */ + public final native void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ *
+ */ + public final native void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ *
+ */ + public final native void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ *
+ */ + public final native void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ *
+ */ + public final native void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ *
+ */ + public final native void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3iv ( const GLint * v ) ;
+ *
+ */ + public final native void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexd ( GLdouble c ) ;
+ *
+ */ + public final native void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexf ( GLfloat c ) ;
+ *
+ */ + public final native void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexi ( GLint c ) ;
+ *
+ */ + public final native void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexs ( GLshort c ) ;
+ *
+ */ + public final native void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexub ( GLubyte c ) ;
+ *
+ */ + public final native void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ *
+ */ + public final native void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ *
+ */ + public final native void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexiv ( const GLint * c ) ;
+ *
+ */ + public final native void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexsv ( const GLshort * c ) ;
+ *
+ */ + public final native void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ *
+ */ + public final native void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ *
+ */ + public final native void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ *
+ */ + public final native void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ *
+ */ + public final native void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ *
+ */ + public final native void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ *
+ */ + public final native void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ *
+ */ + public final native void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ *
+ */ + public final native void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ *
+ */ + public final native void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ *
+ */ + public final native void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ *
+ */ + public final native void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public final native void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ *
+ */ + public final native void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ *
+ */ + public final native void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ *
+ */ + public final native void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ *
+ */ + public final native void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ *
+ */ + public final native void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ *
+ */ + public final native void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3iv ( const GLint * v ) ;
+ *
+ */ + public final native void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ *
+ */ + public final native void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ *
+ */ + public final native void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3usv ( const GLushort * v ) ;
+ *
+ */ + public final native void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ *
+ */ + public final native void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4iv ( const GLint * v ) ;
+ *
+ */ + public final native void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ *
+ */ + public final native void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ *
+ */ + public final native void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4usv ( const GLushort * v ) ;
+ *
+ */ + public final native void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ *
+ */ + public final native void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ *
+ */ + public final native void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1i ( GLint s ) ;
+ *
+ */ + public final native void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1s ( GLshort s ) ;
+ *
+ */ + public final native void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ *
+ */ + public final native void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ *
+ */ + public final native void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ *
+ */ + public final native void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ *
+ */ + public final native void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public final native void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public final native void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ *
+ */ + public final native void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public final native void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public final native void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public final native void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public final native void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public final native void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ *
+ */ + public final native void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ *
+ */ + public final native void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ *
+ */ + public final native void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ *
+ */ + public final native void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public final native void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public final native void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ *
+ */ + public final native void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public final native void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public final native void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public final native void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public final native void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public final native void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public final native void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public final native void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public final native void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ *
+ */ + public final native void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ *
+ */ + public final native void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ *
+ */ + public final native void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ *
+ */ + public final native void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ *
+ */ + public final native void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ *
+ */ + public final native void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ *
+ */ + public final native void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ *
+ */ + public final native void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ *
+ */ + public final native void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ *
+ */ + public final native void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ *
+ */ + public final native void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ *
+ */ + public final native void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ *
+ */ + public final native void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ *
+ */ + public final native void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glVertexPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public final native void glVertexPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glNormalPointer ( + int type, + int stride, + byte[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + short[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + int[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + float[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + double[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public final native void glNormalPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glColorPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public final native void glColorPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glIndexPointer ( + int type, + int stride, + byte[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + short[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + int[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + float[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + double[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public final native void glIndexPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public final native void glTexCoordPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glEdgeFlagPointer ( + int stride, + byte[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + short[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + int[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + float[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + double[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + boolean[] ptr + ) ; + public final native void glEdgeFlagPointer ( + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ *
+ */ + public final native void glGetPointerv ( + int pname, + byte[][] params + ) ; + public final native void glGetPointerv ( + int pname, + short[][] params + ) ; + public final native void glGetPointerv ( + int pname, + int[][] params + ) ; + public final native void glGetPointerv ( + int pname, + float[][] params + ) ; + public final native void glGetPointerv ( + int pname, + double[][] params + ) ; + public final native void glGetPointerv ( + int pname, + boolean[][] params + ) ; + public final native void glGetPointerv ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElement ( GLint i ) ;
+ *
+ */ + public final native void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public final native void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public final native void glDrawElements ( + int mode, + int count, + int type, + byte[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + short[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + int[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + float[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + double[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + boolean[] indices + ) ; + public final native void glDrawElements ( + int mode, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ *
+ */ + public final native void glInterleavedArrays ( + int format, + int stride, + byte[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + short[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + int[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + float[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + double[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + boolean[] pointer + ) ; + public final native void glInterleavedArrays ( + int format, + int stride, + long[] pointer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glShadeModel ( GLenum mode ) ;
+ *
+ */ + public final native void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ *
+ */ + public final native void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ *
+ */ + public final native void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ *
+ */ + public final native void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ *
+ */ + public final native void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ *
+ */ + public final native void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ *
+ */ + public final native void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ *
+ */ + public final native void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ *
+ */ + public final native void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ *
+ */ + public final native void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public final native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public final native void glDrawPixels ( + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ *
+ */ + public final native void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ *
+ */ + public final native void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilMask ( GLuint mask ) ;
+ *
+ */ + public final native void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ *
+ */ + public final native void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearStencil ( GLint s ) ;
+ *
+ */ + public final native void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ *
+ */ + public final native void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ *
+ */ + public final native void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ *
+ */ + public final native void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + short[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + int[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + float[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + double[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + short[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + int[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + float[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + double[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + byte[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + short[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + int[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + float[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + double[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + boolean[] pixels + ) ; + public final native void glGetTexImage ( + int target, + int level, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public final native void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public final native void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ *
+ */ + public final native void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public final native void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public final native boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ *
+ */ + public final native boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + short[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + int[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + float[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + double[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ *
+ */ + public final native void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ *
+ */ + public final native void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public final native void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ *
+ */ + public final native void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ *
+ */ + public final native void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ *
+ */ + public final native void glMap2d ( + int target, + double u1, + double u2, + int ustride, + int uorder, + double v1, + double v2, + int vstride, + int vorder, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ *
+ */ + public final native void glMap2f ( + int target, + float u1, + float u2, + int ustride, + int uorder, + float v1, + float v2, + int vstride, + int vorder, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ *
+ */ + public final native void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ *
+ */ + public final native void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ *
+ */ + public final native void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ *
+ */ + public final native void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ *
+ */ + public final native void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ *
+ */ + public final native void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ *
+ */ + public final native void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ *
+ */ + public final native void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ *
+ */ + public final native void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ *
+ */ + public final native void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ *
+ */ + public final native void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ *
+ */ + public final native void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ *
+ */ + public final native void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ *
+ */ + public final native void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ *
+ */ + public final native void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint1 ( GLint i ) ;
+ *
+ */ + public final native void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ *
+ */ + public final native void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ *
+ */ + public final native void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ *
+ */ + public final native void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ *
+ */ + public final native void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ *
+ */ + public final native void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPassThrough ( GLfloat token ) ;
+ *
+ */ + public final native void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ *
+ */ + public final native void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInitNames ( void ) ;
+ *
+ */ + public final native void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadName ( GLuint name ) ;
+ *
+ */ + public final native void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushName ( GLuint name ) ;
+ *
+ */ + public final native void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopName ( void ) ;
+ *
+ */ + public final native void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + byte[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + short[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + int[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + float[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + double[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + boolean[] indices + ) ; + public final native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glCopyTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public final native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public final native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public final native void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public final native void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public final native void glGetColorTable ( + int target, + int format, + int type, + byte[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + short[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + int[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + float[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + double[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + boolean[] table + ) ; + public final native void glGetColorTable ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquation ( GLenum mode ) ;
+ *
+ */ + public final native void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public final native void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public final native void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetHistogram ( GLenum target ) ;
+ *
+ */ + public final native void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ *
+ */ + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + byte[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + short[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + int[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + float[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + double[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + boolean[] values + ) ; + public final native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public final native void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetMinmax ( GLenum target ) ;
+ *
+ */ + public final native void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ *
+ */ + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + byte[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + short[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + int[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + float[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + double[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + boolean[] values + ) ; + public final native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + short[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + int[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + float[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + double[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] image + ) ; + public final native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] image + ) ; + public final native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ *
+ */ + public final native void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ *
+ */ + public final native void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public final native void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public final native void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ *
+ */ + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + byte[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + short[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + int[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + float[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + double[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + boolean[] image + ) ; + public final native void glGetConvolutionFilter ( + int target, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ *
+ */ + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] row, + byte[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] row, + short[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] row, + int[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] row, + float[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] row, + double[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] row, + boolean[] column + ) ; + public final native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] row, + long[] column + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ *
+ */ + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + byte[] row, + byte[] column, + byte[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + short[] row, + short[] column, + short[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + int[] row, + int[] column, + int[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + float[] row, + float[] column, + float[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + double[] row, + double[] column, + double[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + boolean[] row, + boolean[] column, + boolean[] span + ) ; + public final native void glGetSeparableFilter ( + int target, + int format, + int type, + long[] row, + long[] column, + long[] span + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public final native void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ *
+ */ + public final native void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public final native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public final native void glCopyTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public final native void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public final native void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ *
+ */ + public final native void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public final native void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public final native boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ *
+ */ + public final native boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public final native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public final native void glNormalPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public final native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public final native void glIndexPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public final native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ *
+ */ + public final native void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ *
+ */ + public final native void glGetPointervEXT ( + int pname, + byte[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + short[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + int[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + float[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + double[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + boolean[][] params + ) ; + public final native void glGetPointervEXT ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElementEXT ( GLint i ) ;
+ *
+ */ + public final native void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public final native void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ *
+ */ + public final native void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public final native void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public final native void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public final native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public final native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + byte[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + short[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + int[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + float[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + double[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + boolean[] table + ) ; + public final native void glGetColorTableEXT ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public final native void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public final native void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ *
+ */ + public final native void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glUnlockArraysEXT ( void ) ;
+ *
+ */ + public final native void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public final native void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public final native void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ *
+ */ + public final native void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public final native void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ *
+ */ + public final native void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public final native void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ *
+ */ + public final native void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public final native void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ *
+ */ + public final native void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public final native void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ *
+ */ + public final native void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public final native void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ *
+ */ + public final native void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public final native void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ *
+ */ + public final native void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public final native void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ *
+ */ + public final native void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public final native void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public final native void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public final native void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public final native void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public final native void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ *
+ */ + public final native void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public final native void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public final native void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public final native void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public final native void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public final native void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public final native void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public final native void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public final native void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public final native void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public final native void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public final native void glMultiTexCoord4svARB ( + int target, + short[] v + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLFuncJauJNInf.java b/gl4java/GLFuncJauJNInf.java new file mode 100644 index 0000000..7ef0155 --- /dev/null +++ b/gl4java/GLFuncJauJNInf.java @@ -0,0 +1,6997 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLFuncJauJNInf.java + */ + + +package gl4java; + +/** + * The default implementation class for OpenGL native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public class GLFuncJauJNInf + implements GLFunc +{ + + + +public native String glGetString ( int name ) ; + +public native String getNativeVendor ( ) ; +public native String getNativeVersion ( ) ; + +public String getClassVendor ( ) +{ return "Jausoft - Sven Goethel Software Development"; } + +public String getClassVersion ( ) +{ return "2.4.1.0"; } + + + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: gl-proto-auto.orig . . . + * Destination-Class: gl4java_GLFuncJauJNInf ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearIndex ( GLfloat c ) ;
+ *
+ */ + public native void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public native void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClear ( GLbitfield mask ) ;
+ *
+ */ + public native void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexMask ( GLuint mask ) ;
+ *
+ */ + public native void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ *
+ */ + public native void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ *
+ */ + public native void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ *
+ */ + public native void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLogicOp ( GLenum opcode ) ;
+ *
+ */ + public native void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCullFace ( GLenum mode ) ;
+ *
+ */ + public native void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrontFace ( GLenum mode ) ;
+ *
+ */ + public native void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointSize ( GLfloat size ) ;
+ *
+ */ + public native void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineWidth ( GLfloat width ) ;
+ *
+ */ + public native void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ *
+ */ + public native void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ *
+ */ + public native void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ *
+ */ + public native void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ *
+ */ + public native void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ *
+ */ + public native void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ *
+ */ + public native void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ *
+ */ + public native void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ *
+ */ + public native void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ *
+ */ + public native void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ *
+ */ + public native void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadBuffer ( GLenum mode ) ;
+ *
+ */ + public native void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnable ( GLenum cap ) ;
+ *
+ */ + public native void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisable ( GLenum cap ) ;
+ *
+ */ + public native void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ *
+ */ + public native boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnableClientState ( GLenum cap ) ;
+ *
+ */ + public native void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDisableClientState ( GLenum cap ) ;
+ *
+ */ + public native void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ *
+ */ + public native void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ *
+ */ + public native void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ *
+ */ + public native void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopAttrib ( void ) ;
+ *
+ */ + public native void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ *
+ */ + public native void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopClientAttrib ( void ) ;
+ *
+ */ + public native void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ *
+ */ + public native int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLenum glGetError ( void ) ;
+ *
+ */ + public native int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFinish ( void ) ;
+ *
+ */ + public native void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFlush ( void ) ;
+ *
+ */ + public native void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ *
+ */ + public native void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearDepth ( GLclampd depth ) ;
+ *
+ */ + public native void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthFunc ( GLenum func ) ;
+ *
+ */ + public native void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthMask ( GLboolean flag ) ;
+ *
+ */ + public native void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ *
+ */ + public native void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public native void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ *
+ */ + public native void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMatrixMode ( GLenum mode ) ;
+ *
+ */ + public native void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public native void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ *
+ */ + public native void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushMatrix ( void ) ;
+ *
+ */ + public native void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopMatrix ( void ) ;
+ *
+ */ + public native void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadIdentity ( void ) ;
+ *
+ */ + public native void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public native void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public native void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ *
+ */ + public native void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ *
+ */ + public native void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public native void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public native void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public native void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsList ( GLuint list ) ;
+ *
+ */ + public native boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ *
+ */ + public native void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ *
+ */ + public native int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ *
+ */ + public native void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEndList ( void ) ;
+ *
+ */ + public native void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallList ( GLuint list ) ;
+ *
+ */ + public native void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ *
+ */ + public native void glCallLists ( + int n, + int type, + byte[] lists + ) ; + public native void glCallLists ( + int n, + int type, + short[] lists + ) ; + public native void glCallLists ( + int n, + int type, + int[] lists + ) ; + public native void glCallLists ( + int n, + int type, + float[] lists + ) ; + public native void glCallLists ( + int n, + int type, + double[] lists + ) ; + public native void glCallLists ( + int n, + int type, + boolean[] lists + ) ; + public native void glCallLists ( + int n, + int type, + long[] lists + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glListBase ( GLuint base ) ;
+ *
+ */ + public native void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBegin ( GLenum mode ) ;
+ *
+ */ + public native void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEnd ( void ) ;
+ *
+ */ + public native void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public native void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public native void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ *
+ */ + public native void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public native void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public native void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public native void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public native void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public native void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public native void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public native void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public native void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2iv ( const GLint * v ) ;
+ *
+ */ + public native void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ *
+ */ + public native void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3iv ( const GLint * v ) ;
+ *
+ */ + public native void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ *
+ */ + public native void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4iv ( const GLint * v ) ;
+ *
+ */ + public native void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ *
+ */ + public native void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ *
+ */ + public native void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ *
+ */ + public native void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ *
+ */ + public native void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ *
+ */ + public native void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ *
+ */ + public native void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ *
+ */ + public native void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3iv ( const GLint * v ) ;
+ *
+ */ + public native void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ *
+ */ + public native void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexd ( GLdouble c ) ;
+ *
+ */ + public native void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexf ( GLfloat c ) ;
+ *
+ */ + public native void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexi ( GLint c ) ;
+ *
+ */ + public native void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexs ( GLshort c ) ;
+ *
+ */ + public native void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexub ( GLubyte c ) ;
+ *
+ */ + public native void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ *
+ */ + public native void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ *
+ */ + public native void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexiv ( const GLint * c ) ;
+ *
+ */ + public native void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexsv ( const GLshort * c ) ;
+ *
+ */ + public native void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ *
+ */ + public native void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ *
+ */ + public native void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ *
+ */ + public native void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ *
+ */ + public native void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ *
+ */ + public native void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ *
+ */ + public native void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ *
+ */ + public native void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ *
+ */ + public native void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ *
+ */ + public native void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ *
+ */ + public native void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ *
+ */ + public native void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ *
+ */ + public native void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ *
+ */ + public native void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ *
+ */ + public native void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ *
+ */ + public native void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ *
+ */ + public native void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ *
+ */ + public native void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ *
+ */ + public native void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3iv ( const GLint * v ) ;
+ *
+ */ + public native void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3sv ( const GLshort * v ) ;
+ *
+ */ + public native void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ *
+ */ + public native void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ *
+ */ + public native void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor3usv ( const GLushort * v ) ;
+ *
+ */ + public native void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ *
+ */ + public native void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4iv ( const GLint * v ) ;
+ *
+ */ + public native void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4sv ( const GLshort * v ) ;
+ *
+ */ + public native void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ *
+ */ + public native void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ *
+ */ + public native void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColor4usv ( const GLushort * v ) ;
+ *
+ */ + public native void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ *
+ */ + public native void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ *
+ */ + public native void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1i ( GLint s ) ;
+ *
+ */ + public native void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1s ( GLshort s ) ;
+ *
+ */ + public native void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ *
+ */ + public native void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ *
+ */ + public native void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ *
+ */ + public native void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ *
+ */ + public native void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public native void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public native void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ *
+ */ + public native void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public native void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public native void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public native void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public native void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public native void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ *
+ */ + public native void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ *
+ */ + public native void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ *
+ */ + public native void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ *
+ */ + public native void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ *
+ */ + public native void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ *
+ */ + public native void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ *
+ */ + public native void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ *
+ */ + public native void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ *
+ */ + public native void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ *
+ */ + public native void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ *
+ */ + public native void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ *
+ */ + public native void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ *
+ */ + public native void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ *
+ */ + public native void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ *
+ */ + public native void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ *
+ */ + public native void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ *
+ */ + public native void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ *
+ */ + public native void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ *
+ */ + public native void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ *
+ */ + public native void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ *
+ */ + public native void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ *
+ */ + public native void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ *
+ */ + public native void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ *
+ */ + public native void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ *
+ */ + public native void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ *
+ */ + public native void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ *
+ */ + public native void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ *
+ */ + public native void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ *
+ */ + public native void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ *
+ */ + public native void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ *
+ */ + public native void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ *
+ */ + public native void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ *
+ */ + public native void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ *
+ */ + public native void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ *
+ */ + public native void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glVertexPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public native void glVertexPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glNormalPointer ( + int type, + int stride, + byte[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + short[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + int[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + float[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + double[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public native void glNormalPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glColorPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public native void glColorPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glIndexPointer ( + int type, + int stride, + byte[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + short[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + int[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + float[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + double[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + boolean[] ptr + ) ; + public native void glIndexPointer ( + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glTexCoordPointer ( + int size, + int type, + int stride, + byte[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + short[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + int[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + float[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + double[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + boolean[] ptr + ) ; + public native void glTexCoordPointer ( + int size, + int type, + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ *
+ */ + public native void glEdgeFlagPointer ( + int stride, + byte[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + short[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + int[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + float[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + double[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + boolean[] ptr + ) ; + public native void glEdgeFlagPointer ( + int stride, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ *
+ */ + public native void glGetPointerv ( + int pname, + byte[][] params + ) ; + public native void glGetPointerv ( + int pname, + short[][] params + ) ; + public native void glGetPointerv ( + int pname, + int[][] params + ) ; + public native void glGetPointerv ( + int pname, + float[][] params + ) ; + public native void glGetPointerv ( + int pname, + double[][] params + ) ; + public native void glGetPointerv ( + int pname, + boolean[][] params + ) ; + public native void glGetPointerv ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElement ( GLint i ) ;
+ *
+ */ + public native void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public native void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public native void glDrawElements ( + int mode, + int count, + int type, + byte[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + short[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + int[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + float[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + double[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + boolean[] indices + ) ; + public native void glDrawElements ( + int mode, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ *
+ */ + public native void glInterleavedArrays ( + int format, + int stride, + byte[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + short[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + int[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + float[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + double[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + boolean[] pointer + ) ; + public native void glInterleavedArrays ( + int format, + int stride, + long[] pointer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glShadeModel ( GLenum mode ) ;
+ *
+ */ + public native void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ *
+ */ + public native void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ *
+ */ + public native void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ *
+ */ + public native void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ *
+ */ + public native void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ *
+ */ + public native void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ *
+ */ + public native void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ *
+ */ + public native void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ *
+ */ + public native void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ *
+ */ + public native void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ *
+ */ + public native void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ *
+ */ + public native void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ *
+ */ + public native void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ *
+ */ + public native void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ *
+ */ + public native void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public native void glReadPixels ( + int x, + int y, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public native void glDrawPixels ( + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ *
+ */ + public native void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ *
+ */ + public native void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilMask ( GLuint mask ) ;
+ *
+ */ + public native void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ *
+ */ + public native void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClearStencil ( GLint s ) ;
+ *
+ */ + public native void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ *
+ */ + public native void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ *
+ */ + public native void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ *
+ */ + public native void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ *
+ */ + public native void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public native void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ *
+ */ + public native void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + byte[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + short[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + int[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + float[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + double[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexImage1D ( + int target, + int level, + int internalFormat, + int width, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + byte[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + short[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + int[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + float[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + double[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexImage2D ( + int target, + int level, + int internalFormat, + int width, + int height, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ *
+ */ + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + byte[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + short[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + int[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + float[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + double[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + boolean[] pixels + ) ; + public native void glGetTexImage ( + int target, + int level, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public native void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public native void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ *
+ */ + public native void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public native void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public native boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ *
+ */ + public native boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + byte[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + short[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + int[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + float[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + double[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexSubImage1D ( + int target, + int level, + int xoffset, + int width, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + byte[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + short[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + int[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + float[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + double[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ *
+ */ + public native void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ *
+ */ + public native void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public native void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ *
+ */ + public native void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ *
+ */ + public native void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ *
+ */ + public native void glMap2d ( + int target, + double u1, + double u2, + int ustride, + int uorder, + double v1, + double v2, + int vstride, + int vorder, + double[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ *
+ */ + public native void glMap2f ( + int target, + float u1, + float u2, + int ustride, + int uorder, + float v1, + float v2, + int vstride, + int vorder, + float[] points + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ *
+ */ + public native void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ *
+ */ + public native void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ *
+ */ + public native void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ *
+ */ + public native void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ *
+ */ + public native void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ *
+ */ + public native void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ *
+ */ + public native void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ *
+ */ + public native void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ *
+ */ + public native void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ *
+ */ + public native void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ *
+ */ + public native void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ *
+ */ + public native void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ *
+ */ + public native void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ *
+ */ + public native void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ *
+ */ + public native void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint1 ( GLint i ) ;
+ *
+ */ + public native void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ *
+ */ + public native void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ *
+ */ + public native void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ *
+ */ + public native void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ *
+ */ + public native void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ *
+ */ + public native void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPassThrough ( GLfloat token ) ;
+ *
+ */ + public native void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ *
+ */ + public native void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glInitNames ( void ) ;
+ *
+ */ + public native void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLoadName ( GLuint name ) ;
+ *
+ */ + public native void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPushName ( GLuint name ) ;
+ *
+ */ + public native void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPopName ( void ) ;
+ *
+ */ + public native void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ *
+ */ + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + byte[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + short[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + int[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + float[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + double[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + boolean[] indices + ) ; + public native void glDrawRangeElements ( + int mode, + int start, + int end, + int count, + int type, + long[] indices + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexImage3D ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glCopyTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public native void glColorTable ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public native void glColorSubTable ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public native void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public native void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public native void glGetColorTable ( + int target, + int format, + int type, + byte[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + short[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + int[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + float[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + double[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + boolean[] table + ) ; + public native void glGetColorTable ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquation ( GLenum mode ) ;
+ *
+ */ + public native void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public native void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public native void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetHistogram ( GLenum target ) ;
+ *
+ */ + public native void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ *
+ */ + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + byte[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + short[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + int[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + float[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + double[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + boolean[] values + ) ; + public native void glGetHistogram ( + int target, + boolean reset, + int format, + int type, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ *
+ */ + public native void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glResetMinmax ( GLenum target ) ;
+ *
+ */ + public native void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ *
+ */ + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + byte[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + short[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + int[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + float[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + double[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + boolean[] values + ) ; + public native void glGetMinmax ( + int target, + boolean reset, + int format, + int types, + long[] values + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + short[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + int[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + float[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + double[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] image + ) ; + public native void glConvolutionFilter1D ( + int target, + int internalformat, + int width, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ *
+ */ + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] image + ) ; + public native void glConvolutionFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ *
+ */ + public native void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ *
+ */ + public native void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ *
+ */ + public native void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ *
+ */ + public native void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ *
+ */ + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + byte[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + short[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + int[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + float[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + double[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + boolean[] image + ) ; + public native void glGetConvolutionFilter ( + int target, + int format, + int type, + long[] image + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ *
+ */ + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + byte[] row, + byte[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + short[] row, + short[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + int[] row, + int[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + float[] row, + float[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + double[] row, + double[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + boolean[] row, + boolean[] column + ) ; + public native void glSeparableFilter2D ( + int target, + int internalformat, + int width, + int height, + int format, + int type, + long[] row, + long[] column + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ *
+ */ + public native void glGetSeparableFilter ( + int target, + int format, + int type, + byte[] row, + byte[] column, + byte[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + short[] row, + short[] column, + short[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + int[] row, + int[] column, + int[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + float[] row, + float[] column, + float[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + double[] row, + double[] column, + double[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + boolean[] row, + boolean[] column, + boolean[] span + ) ; + public native void glGetSeparableFilter ( + int target, + int format, + int type, + long[] row, + long[] column, + long[] span + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ *
+ */ + public native void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ *
+ */ + public native void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + byte[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + short[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + int[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + float[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + double[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexImage3DEXT ( + int target, + int level, + int internalFormat, + int width, + int height, + int depth, + int border, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ *
+ */ + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + byte[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + short[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + int[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + float[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + double[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + boolean[] pixels + ) ; + public native void glTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int width, + int height, + int depth, + int format, + int type, + long[] pixels + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ *
+ */ + public native void glCopyTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ *
+ */ + public native void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ *
+ */ + public native void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ *
+ */ + public native void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ *
+ */ + public native void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ *
+ */ + public native boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ *
+ */ + public native boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public native void glVertexPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public native void glNormalPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public native void glColorPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + byte[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + short[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + int[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + float[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + double[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + boolean[] ptr + ) ; + public native void glIndexPointerEXT ( + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ *
+ */ + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + byte[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + short[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + int[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + float[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + double[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + boolean[] ptr + ) ; + public native void glTexCoordPointerEXT ( + int size, + int type, + int stride, + int count, + long[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ *
+ */ + public native void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ *
+ */ + public native void glGetPointervEXT ( + int pname, + byte[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + short[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + int[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + float[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + double[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + boolean[][] params + ) ; + public native void glGetPointervEXT ( + int pname, + long[][] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glArrayElementEXT ( GLint i ) ;
+ *
+ */ + public native void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ *
+ */ + public native void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ *
+ */ + public native void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ *
+ */ + public native void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ *
+ */ + public native void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ *
+ */ + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + byte[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + short[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + int[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + float[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + double[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + boolean[] table + ) ; + public native void glColorTableEXT ( + int target, + int internalformat, + int width, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ *
+ */ + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + byte[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + short[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + int[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + float[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + double[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + boolean[] data + ) ; + public native void glColorSubTableEXT ( + int target, + int start, + int count, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ *
+ */ + public native void glGetColorTableEXT ( + int target, + int format, + int type, + byte[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + short[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + int[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + float[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + double[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + boolean[] table + ) ; + public native void glGetColorTableEXT ( + int target, + int format, + int type, + long[] table + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ *
+ */ + public native void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ *
+ */ + public native void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ *
+ */ + public native void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glUnlockArraysEXT ( void ) ;
+ *
+ */ + public native void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public native void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ *
+ */ + public native void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ *
+ */ + public native void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public native void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ *
+ */ + public native void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public native void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ *
+ */ + public native void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public native void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ *
+ */ + public native void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public native void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ *
+ */ + public native void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public native void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ *
+ */ + public native void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public native void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ *
+ */ + public native void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public native void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ *
+ */ + public native void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public native void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ *
+ */ + public native void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public native void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ *
+ */ + public native void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public native void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ *
+ */ + public native void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public native void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ *
+ */ + public native void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public native void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ *
+ */ + public native void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ *
+ */ + public native void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ *
+ */ + public native void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ *
+ */ + public native void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ *
+ */ + public native void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ *
+ */ + public native void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ *
+ */ + public native void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ *
+ */ + public native void glMultiTexCoord4svARB ( + int target, + short[] v + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLUEnum.java b/gl4java/GLUEnum.java new file mode 100644 index 0000000..accda94 --- /dev/null +++ b/gl4java/GLUEnum.java @@ -0,0 +1,141 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLUEnum.java + */ + + +package gl4java; + +/** + * The base interface for GLU enumerates, + * which provides you all the C-API style enumerates + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public interface GLUEnum +{ + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: glu-enum-auto.orig . . . + * Destination-Class: gl4java_GLUEnum ! + */ + + public static final int GLU_AUTO_LOAD_MATRIX = 100200; + public static final int GLU_CCW = 100121; + public static final int GLU_CULLING = 100201; + public static final int GLU_CW = 100120; + public static final int GLU_DISPLAY_MODE = 100204; + public static final int GLU_DOMAIN_DISTANCE = 100217; + public static final int GLU_EXTENSIONS = 100801; + public static final int GLU_EXTERIOR = 100123; + public static final int GLU_FALSE = 0; + public static final int GLU_FILL = 100012; + public static final int GLU_FLAT = 100001; + public static final int GLU_INCOMPATIBLE_GL_VERSION = 100903; + public static final int GLU_INSIDE = 100021; + public static final int GLU_INTERIOR = 100122; + public static final int GLU_INVALID_ENUM = 100900; + public static final int GLU_INVALID_VALUE = 100901; + public static final int GLU_LINE = 100011; + public static final int GLU_MAP1_TRIM_2 = 100210; + public static final int GLU_MAP1_TRIM_3 = 100211; + public static final int GLU_NONE = 100002; + public static final int GLU_NURBS_ERROR1 = 100251; + public static final int GLU_NURBS_ERROR10 = 100260; + public static final int GLU_NURBS_ERROR11 = 100261; + public static final int GLU_NURBS_ERROR12 = 100262; + public static final int GLU_NURBS_ERROR13 = 100263; + public static final int GLU_NURBS_ERROR14 = 100264; + public static final int GLU_NURBS_ERROR15 = 100265; + public static final int GLU_NURBS_ERROR16 = 100266; + public static final int GLU_NURBS_ERROR17 = 100267; + public static final int GLU_NURBS_ERROR18 = 100268; + public static final int GLU_NURBS_ERROR19 = 100269; + public static final int GLU_NURBS_ERROR2 = 100252; + public static final int GLU_NURBS_ERROR20 = 100270; + public static final int GLU_NURBS_ERROR21 = 100271; + public static final int GLU_NURBS_ERROR22 = 100272; + public static final int GLU_NURBS_ERROR23 = 100273; + public static final int GLU_NURBS_ERROR24 = 100274; + public static final int GLU_NURBS_ERROR25 = 100275; + public static final int GLU_NURBS_ERROR26 = 100276; + public static final int GLU_NURBS_ERROR27 = 100277; + public static final int GLU_NURBS_ERROR28 = 100278; + public static final int GLU_NURBS_ERROR29 = 100279; + public static final int GLU_NURBS_ERROR3 = 100253; + public static final int GLU_NURBS_ERROR30 = 100280; + public static final int GLU_NURBS_ERROR31 = 100281; + public static final int GLU_NURBS_ERROR32 = 100282; + public static final int GLU_NURBS_ERROR33 = 100283; + public static final int GLU_NURBS_ERROR34 = 100284; + public static final int GLU_NURBS_ERROR35 = 100285; + public static final int GLU_NURBS_ERROR36 = 100286; + public static final int GLU_NURBS_ERROR37 = 100287; + public static final int GLU_NURBS_ERROR4 = 100254; + public static final int GLU_NURBS_ERROR5 = 100255; + public static final int GLU_NURBS_ERROR6 = 100256; + public static final int GLU_NURBS_ERROR7 = 100257; + public static final int GLU_NURBS_ERROR8 = 100258; + public static final int GLU_NURBS_ERROR9 = 100259; + public static final int GLU_OUTLINE_PATCH = 100241; + public static final int GLU_OUTLINE_POLYGON = 100240; + public static final int GLU_OUTSIDE = 100020; + public static final int GLU_OUT_OF_MEMORY = 100902; + public static final int GLU_PARAMETRIC_ERROR = 100216; + public static final int GLU_PARAMETRIC_TOLERANCE = 100202; + public static final int GLU_PATH_LENGTH = 100215; + public static final int GLU_POINT = 100010; + public static final int GLU_SAMPLING_METHOD = 100205; + public static final int GLU_SAMPLING_TOLERANCE = 100203; + public static final int GLU_SILHOUETTE = 100013; + public static final int GLU_SMOOTH = 100000; + public static final int GLU_TESS_BEGIN = 100100; + public static final int GLU_TESS_BEGIN_DATA = 100106; + public static final int GLU_TESS_BOUNDARY_ONLY = 100141; + public static final int GLU_TESS_COMBINE = 100105; + public static final int GLU_TESS_COMBINE_DATA = 100111; + public static final int GLU_TESS_EDGE_FLAG = 100104; + public static final int GLU_TESS_EDGE_FLAG_DATA = 100110; + public static final int GLU_TESS_END = 100102; + public static final int GLU_TESS_END_DATA = 100108; + public static final int GLU_TESS_ERROR = 100103; + public static final int GLU_TESS_ERROR1 = 100151; + public static final int GLU_TESS_ERROR2 = 100152; + public static final int GLU_TESS_ERROR3 = 100153; + public static final int GLU_TESS_ERROR4 = 100154; + public static final int GLU_TESS_ERROR5 = 100155; + public static final int GLU_TESS_ERROR6 = 100156; + public static final int GLU_TESS_ERROR7 = 100157; + public static final int GLU_TESS_ERROR8 = 100158; + public static final int GLU_TESS_ERROR_DATA = 100109; + public static final int GLU_TESS_TOLERANCE = 100142; + public static final int GLU_TESS_VERTEX = 100101; + public static final int GLU_TESS_VERTEX_DATA = 100107; + public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; + public static final int GLU_TESS_WINDING_NEGATIVE = 100133; + public static final int GLU_TESS_WINDING_NONZERO = 100131; + public static final int GLU_TESS_WINDING_ODD = 100130; + public static final int GLU_TESS_WINDING_POSITIVE = 100132; + public static final int GLU_TESS_WINDING_RULE = 100140; + public static final int GLU_UNKNOWN = 100124; + public static final int GLU_U_STEP = 100206; + public static final int GLU_VERSION = 100800; + public static final int GLU_V_STEP = 100207; + public static final int GLU_VERTEX = GLU_TESS_VERTEX; + public static final int GLU_BEGIN = GLU_TESS_BEGIN; + public static final int GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG; + public static final int GLU_END = GLU_TESS_END; + public static final int GLU_ERROR = GLU_TESS_ERROR; +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLUFunc.java b/gl4java/GLUFunc.java new file mode 100644 index 0000000..0232eae --- /dev/null +++ b/gl4java/GLUFunc.java @@ -0,0 +1,774 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLUFunc.java + */ + + +package gl4java; + +/** + * The base interface for GLU native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public interface GLUFunc + extends GLUEnum +{ + +public String gluErrorString ( int errorCode ) ; + +public String gluGetString ( int name ) ; + +public String getNativeVendor ( ) ; +public String getNativeVersion ( ) ; + +public String getClassVendor ( ) ; +public String getClassVersion ( ) ; + +public void gluQuadricCallback( + int qobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + +public void gluNurbsCallback( + int nobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + + +public void gluTessCallback( + int tobj, int which, + Object methodClassInstance, + String methodName, + String signature, + int voidArrayLen1, + int voidArrayLen2, + int voidArrayLen3, + int voidArrayLen4, + int voidArrayLen5 + ); + +public void gluDeleteQuadric( int qobj ); + +public void gluDeleteNurbsRenderer( int nobj ); + +public void gluDeleteTess( int tobj ); + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: glu-proto-auto.orig . . . + * Destination-Class: gl4java_GLUFuncJauJNI ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ *
+ */ + public void gluLookAt ( + double eyex, + double eyey, + double eyez, + double centerx, + double centery, + double centerz, + double upx, + double upy, + double upz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ *
+ */ + public void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ *
+ */ + public void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ *
+ */ + public void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ *
+ */ + public int gluProject ( + double objx, + double objy, + double objz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] winx, + double[] winy, + double[] winz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ *
+ */ + public int gluUnProject ( + double winx, + double winy, + double winz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] objx, + double[] objy, + double[] objz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ *
+ */ + public int gluScaleImage ( + int format, + int widthin, + int heightin, + int typein, + byte[] datain, + int widthout, + int heightout, + int typeout, + byte[] dataout + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + byte[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + short[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + int[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + float[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + double[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + boolean[] data + ) ; + public int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + byte[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + short[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + int[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + float[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + double[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + boolean[] data + ) ; + public int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ *
+ */ + public int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ *
+ */ + public void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ *
+ */ + public void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ *
+ */ + public void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ *
+ */ + public void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ *
+ */ + public void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ *
+ */ + public void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ *
+ */ + public void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ *
+ */ + public void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ *
+ */ + public int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ *
+ */ + public void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ *
+ */ + public void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ *
+ */ + public void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ *
+ */ + public void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ *
+ */ + public void gluNurbsSurface ( + int nobj, + int sknot_count, + float[] sknot, + int tknot_count, + float[] tknot, + int s_stride, + int t_stride, + float[] ctlarray, + int sorder, + int torder, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ *
+ */ + public void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ *
+ */ + public int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ *
+ */ + public void gluTessBeginPolygon ( + int tobj, + byte[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + short[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + int[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + float[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + double[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + boolean[] polygon_data + ) ; + public void gluTessBeginPolygon ( + int tobj, + long[] polygon_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ *
+ */ + public void gluTessVertex ( + int tobj, + double[] coords, + byte[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + short[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + int[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + float[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + double[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + boolean[] vertex_data + ) ; + public void gluTessVertex ( + int tobj, + double[] coords, + long[] vertex_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ *
+ */ + public void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ *
+ */ + public void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ *
+ */ + public void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public void gluEndPolygon ( + int tobj + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLUFuncJauJNI.java b/gl4java/GLUFuncJauJNI.java new file mode 100644 index 0000000..12843f7 --- /dev/null +++ b/gl4java/GLUFuncJauJNI.java @@ -0,0 +1,848 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLUFuncJauJNI.java + */ + + +package gl4java; + +/** + * The default implementation class for GLU native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public class GLUFuncJauJNI + implements GLUFunc +{ + + +public final native String gluErrorString ( int errorCode ) ; +public final native String gluGetString ( int name ) ; + +public final native String getNativeVendor ( ) ; +public final native String getNativeVersion ( ) ; + +public final String getClassVendor ( ) +{ return "Jausoft - Sven Goethel Software Development"; } + +public final String getClassVersion ( ) +{ return "2.4.1.0"; } + + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param qobj the quadratic id, fetch with gluNewQuadric + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * + * @see GLUFunc#gluNewQuadric + */ +public final native void gluQuadricCallback( + int qobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param nobj the nurbs id, fetch with gluNewNurbsRenderer + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * + * @see GLUFunc#gluNewNurbsRenderer + */ +public final native void gluNurbsCallback( + int nobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param tobj the tesselation id, fetch with gluNewTess + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * @param voidArrayLen1 the optional length of the 1st array + * in the callback-methods argument-list + * @param voidArrayLen2 the optional length of the 2nd array + * in the callback-methods argument-list + * @param voidArrayLen3 the optional length of the 3rd array + * in the callback-methods argument-list + * @param voidArrayLen4 the optional length of the 4th array + * in the callback-methods argument-list + * @param voidArrayLen5 the optional length of the 5th array + * in the callback-methods argument-list + * + * @see GLUFunc#gluNewTess + */ +public final native void gluTessCallback( + int tobj, int which, + Object methodClassInstance, + String methodName, + String signature, + int voidArrayLen1, + int voidArrayLen2, + int voidArrayLen3, + int voidArrayLen4, + int voidArrayLen5 + ); + +/** + * The Callback de-registry function. + * + * @param qobj the quadratic id, for which all callback-methods + * should be de-registered + */ +public final native void gluDeleteQuadric( int qobj ); + +/** + * The Callback de-registry function. + * + * @param nobj the nurbs id, for which all callback-methods + * should be de-registered + */ +public final native void gluDeleteNurbsRenderer( int nobj ); + +/** + * The Callback de-registry function. + * + * @param tobj the tesselation id, for which all callback-methods + * should be de-registered + */ +public final native void gluDeleteTess( int tobj ); + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: glu-proto-auto.orig . . . + * Destination-Class: gl4java_GLUFuncJauJNI ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ *
+ */ + public final native void gluLookAt ( + double eyex, + double eyey, + double eyez, + double centerx, + double centery, + double centerz, + double upx, + double upy, + double upz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ *
+ */ + public final native void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ *
+ */ + public final native void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ *
+ */ + public final native void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ *
+ */ + public final native int gluProject ( + double objx, + double objy, + double objz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] winx, + double[] winy, + double[] winz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ *
+ */ + public final native int gluUnProject ( + double winx, + double winy, + double winz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] objx, + double[] objy, + double[] objz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ *
+ */ + public final native int gluScaleImage ( + int format, + int widthin, + int heightin, + int typein, + byte[] datain, + int widthout, + int heightout, + int typeout, + byte[] dataout + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + byte[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + short[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + int[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + float[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + double[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + boolean[] data + ) ; + public final native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + byte[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + short[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + int[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + float[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + double[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + boolean[] data + ) ; + public final native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ *
+ */ + public final native int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ *
+ */ + public final native void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ *
+ */ + public final native void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ *
+ */ + public final native void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ *
+ */ + public final native void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ *
+ */ + public final native void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ *
+ */ + public final native void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ *
+ */ + public final native void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ *
+ */ + public final native void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ *
+ */ + public final native int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ *
+ */ + public final native void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ *
+ */ + public final native void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ *
+ */ + public final native void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ *
+ */ + public final native void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ *
+ */ + public final native void gluNurbsSurface ( + int nobj, + int sknot_count, + float[] sknot, + int tknot_count, + float[] tknot, + int s_stride, + int t_stride, + float[] ctlarray, + int sorder, + int torder, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public final native void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ *
+ */ + public final native void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ *
+ */ + public final native int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ *
+ */ + public final native void gluTessBeginPolygon ( + int tobj, + byte[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + short[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + int[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + float[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + double[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + boolean[] polygon_data + ) ; + public final native void gluTessBeginPolygon ( + int tobj, + long[] polygon_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public final native void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ *
+ */ + public final native void gluTessVertex ( + int tobj, + double[] coords, + byte[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + short[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + int[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + float[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + double[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + boolean[] vertex_data + ) ; + public final native void gluTessVertex ( + int tobj, + double[] coords, + long[] vertex_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public final native void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public final native void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ *
+ */ + public final native void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public final native void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ *
+ */ + public final native void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public final native void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ *
+ */ + public final native void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public final native void gluEndPolygon ( + int tobj + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLUFuncJauJNInf.java b/gl4java/GLUFuncJauJNInf.java new file mode 100644 index 0000000..51cdbb9 --- /dev/null +++ b/gl4java/GLUFuncJauJNInf.java @@ -0,0 +1,848 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLUFuncJauJNInf.java + */ + + +package gl4java; + +/** + * The default implementation class for GLU native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public class GLUFuncJauJNInf + implements GLUFunc +{ + + +public native String gluErrorString ( int errorCode ) ; +public native String gluGetString ( int name ) ; + +public native String getNativeVendor ( ) ; +public native String getNativeVersion ( ) ; + +public String getClassVendor ( ) +{ return "Jausoft - Sven Goethel Software Development"; } + +public String getClassVersion ( ) +{ return "2.4.1.0"; } + + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param qobj the quadratic id, fetch with gluNewQuadric + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * + * @see GLUFunc#gluNewQuadric + */ +public native void gluQuadricCallback( + int qobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param nobj the nurbs id, fetch with gluNewNurbsRenderer + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * + * @see GLUFunc#gluNewNurbsRenderer + */ +public native void gluNurbsCallback( + int nobj, int which, + Object methodClassInstance, + String methodName, + String signature + ); + + +/** + * The Callback registry function. + * To achieve the signature (internal argument signature) + * you can use the "javap -s " toolkit of the JDK ! + * + * @param tobj the tesselation id, fetch with gluNewTess + * @param which the id for the callback type + * @param methodClassInstance the class instance, + * which implements the callback-method + * @param methodName the name of the callback-method + * @param signature the signature of the callback-method. + * @param voidArrayLen1 the optional length of the 1st array + * in the callback-methods argument-list + * @param voidArrayLen2 the optional length of the 2nd array + * in the callback-methods argument-list + * @param voidArrayLen3 the optional length of the 3rd array + * in the callback-methods argument-list + * @param voidArrayLen4 the optional length of the 4th array + * in the callback-methods argument-list + * @param voidArrayLen5 the optional length of the 5th array + * in the callback-methods argument-list + * + * @see GLUFunc#gluNewTess + */ +public native void gluTessCallback( + int tobj, int which, + Object methodClassInstance, + String methodName, + String signature, + int voidArrayLen1, + int voidArrayLen2, + int voidArrayLen3, + int voidArrayLen4, + int voidArrayLen5 + ); + +/** + * The Callback de-registry function. + * + * @param qobj the quadratic id, for which all callback-methods + * should be de-registered + */ +public native void gluDeleteQuadric( int qobj ); + +/** + * The Callback de-registry function. + * + * @param nobj the nurbs id, for which all callback-methods + * should be de-registered + */ +public native void gluDeleteNurbsRenderer( int nobj ); + +/** + * The Callback de-registry function. + * + * @param tobj the tesselation id, for which all callback-methods + * should be de-registered + */ +public native void gluDeleteTess( int tobj ); + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: glu-proto-auto.orig . . . + * Destination-Class: gl4java_GLUFuncJauJNInf ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ *
+ */ + public native void gluLookAt ( + double eyex, + double eyey, + double eyez, + double centerx, + double centery, + double centerz, + double upx, + double upy, + double upz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ *
+ */ + public native void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ *
+ */ + public native void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ *
+ */ + public native void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ *
+ */ + public native int gluProject ( + double objx, + double objy, + double objz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] winx, + double[] winy, + double[] winz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ *
+ */ + public native int gluUnProject ( + double winx, + double winy, + double winz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] objx, + double[] objy, + double[] objz + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ *
+ */ + public native int gluScaleImage ( + int format, + int widthin, + int heightin, + int typein, + byte[] datain, + int widthout, + int heightout, + int typeout, + byte[] dataout + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + byte[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + short[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + int[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + float[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + double[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + boolean[] data + ) ; + public native int gluBuild1DMipmaps ( + int target, + int components, + int width, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + byte[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + short[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + int[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + float[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + double[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + boolean[] data + ) ; + public native int gluBuild2DMipmaps ( + int target, + int components, + int width, + int height, + int format, + int type, + long[] data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ *
+ */ + public native int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ *
+ */ + public native void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ *
+ */ + public native void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ *
+ */ + public native void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ *
+ */ + public native void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ *
+ */ + public native void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ *
+ */ + public native void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ *
+ */ + public native void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ *
+ */ + public native void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ *
+ */ + public native int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ *
+ */ + public native void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ *
+ */ + public native void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ *
+ */ + public native void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ *
+ */ + public native void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ *
+ */ + public native void gluNurbsSurface ( + int nobj, + int sknot_count, + float[] sknot, + int tknot_count, + float[] tknot, + int s_stride, + int t_stride, + float[] ctlarray, + int sorder, + int torder, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ *
+ */ + public native void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ *
+ */ + public native void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ *
+ */ + public native int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ *
+ */ + public native void gluTessBeginPolygon ( + int tobj, + byte[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + short[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + int[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + float[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + double[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + boolean[] polygon_data + ) ; + public native void gluTessBeginPolygon ( + int tobj, + long[] polygon_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public native void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ *
+ */ + public native void gluTessVertex ( + int tobj, + double[] coords, + byte[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + short[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + int[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + float[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + double[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + boolean[] vertex_data + ) ; + public native void gluTessVertex ( + int tobj, + double[] coords, + long[] vertex_data + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ *
+ */ + public native void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public native void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ *
+ */ + public native void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ *
+ */ + public native void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ *
+ */ + public native void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public native void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ *
+ */ + public native void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * 
 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ *
+ */ + public native void gluEndPolygon ( + int tobj + ) ; + +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/applet/SimpleGLAnimApplet1.java b/gl4java/applet/SimpleGLAnimApplet1.java new file mode 100644 index 0000000..db74690 --- /dev/null +++ b/gl4java/applet/SimpleGLAnimApplet1.java @@ -0,0 +1,270 @@ +/** + * @(#) SimpleGLAnimApplet.java + * @(#) author: Sven Goethel + */ + +package gl4java.applet; + +/* This program is licensed under the LGPL */ + +import java.applet.*; +import java.awt.*; +import java.awt.event.*; +import java.lang.*; +import gl4java.GLContext; +import gl4java.GLFunc; +import gl4java.GLUFunc; +import gl4java.awt.GLAnimCanvas; + +public class SimpleGLAnimApplet1 extends Applet + implements MouseListener, WindowListener, ActionListener, ItemListener +{ + public GLAnimCanvas canvas = null; + + public Button buttonInfo = null; + public Button buttonFps = null; + public TextField textFps = null; + public Checkbox checkUseRepaint = null; + public Checkbox checkUseFpsSleep = null; + public Button buttonReStart = null; + + + Frame fInfo = null; + + /* Initialize the applet */ + + public void init() + { + setLayout(new BorderLayout()); + + Panel pan = new Panel(); + pan.setLayout(new GridLayout(2,3)); + + buttonInfo = new Button("GL4Java"); + buttonInfo.addMouseListener(this); + pan.add(buttonInfo); + + checkUseRepaint = new Checkbox("repaint", true); + checkUseRepaint.addItemListener(this); + pan.add(checkUseRepaint); + + checkUseFpsSleep = new Checkbox("fps-sleep", true); + checkUseFpsSleep.addItemListener(this); + pan.add(checkUseFpsSleep); + + buttonReStart = new Button("start/stop"); + buttonReStart.addMouseListener(this); + pan.add(buttonReStart); + + buttonFps = new Button("fps: "); + buttonFps.addMouseListener(this); + pan.add(buttonFps); + + textFps=new TextField("0000000000"); + textFps.addActionListener(this); + pan.add(textFps); + + add("South",pan); + } + + + public void start() + { + checkUseFpsSleep.setState(canvas.getUseFpsSleep()); + checkUseRepaint.setState(canvas.getUseRepaint()); + canvas.start(); + } + + + public void stop() + { + canvas.stop(); + } + + + public void destroy() + { + if(fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + canvas.stop(); + canvas.cvsDispose(); + } + + + // Methods required for the implementation of MouseListener + public void mouseEntered( MouseEvent evt ) + { + } + + public void mouseExited( MouseEvent evt ) + { + } + + public void mousePressed( MouseEvent evt ) + { + } + + public void mouseReleased( MouseEvent evt ) + { + } + + public void mouseClicked( MouseEvent evt ) + { + Component comp = evt.getComponent(); + + if( canvas!=null && comp.equals(buttonFps) ) + { + double fps = 0; + int a1; + + canvas.stopFpsCounter(); + fps=canvas.getFps(); + a1=(int)(fps*100.0); + fps=(double)a1/100.0; + textFps.setText(String.valueOf(fps)); + canvas.resetFpsCounter(); + } else if( comp.equals(buttonInfo) ) + { + if(fInfo==null && canvas!=null && canvas.getGLContext()!=null) + fInfo = showGLInfo(); + } + else if( comp.equals(buttonReStart) ) + { + canvas.setSuspended(!canvas.isSuspended(), + evt.getClickCount()>1 // -> ReInit + ); + } + } + + public void itemStateChanged( ItemEvent evt ) + { + ItemSelectable comp = evt.getItemSelectable(); + + if( comp.equals(checkUseRepaint ) ) + { + if(canvas!=null) + { + canvas.setUseRepaint(checkUseRepaint.getState()); + System.out.println("canvas uses repaint: "+ + checkUseRepaint.getState()); + } + } + if( comp.equals(checkUseFpsSleep ) ) + { + if(canvas!=null) + { + canvas.setUseFpsSleep(checkUseFpsSleep.getState()); + System.out.println("canvas uses fps-sleep: "+ + checkUseFpsSleep.getState()); + } + } + } + + public void actionPerformed(ActionEvent event) + { + Object source = event.getSource(); + + if ( source == textFps) + { + try { + double FramesPerSec= + Double.valueOf(textFps.getText()).doubleValue(); + if(canvas!=null) + { + canvas.setAnimateFps(FramesPerSec); + canvas.setSuspended(false, true); + } + } catch (NumberFormatException s) { + System.out.println("wrong fps format, use float .."); + } + + } + } + + public void windowOpened(WindowEvent e) + { + } + + public void windowClosing(WindowEvent e) + { + Window w = e.getWindow(); + if(w == fInfo && fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + } + + public void windowClosed(WindowEvent e) + { + Window w = e.getWindow(); + if(w == fInfo && fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + } + + public void windowDeactivated(WindowEvent e) + { + } + + public Frame showGLInfo() + { + if(canvas==null) return null; + + GLContext glc = canvas.getGLContext(); + if(glc==null) return null; + + GLFunc gl = glc.getGLFunc(); + if(gl==null) return null; + + GLUFunc glu = glc.getGLUFunc(); + if(gl==null) return null; + + canvas.setSuspended(true, false); + + Frame f = new Frame("GL4Java Version"); + TextArea info= new TextArea(25, 80); + info.setEditable(false); + f.add(info); + f.setSize(600, 400); + + String str = "null string"; + if( glc.gljMakeCurrent() == false ) + { + str="problem in use() method\n"; + } else { + str=canvas.getGLContext().gljGetVersions(); + if(str==null) + str="could not get versions"; + System.out.println(str); + glc.gljFree(); + } + info.append(str); + + f.addWindowListener(this); + + canvas.setSuspended(false, false); + + f.pack(); + f.setVisible(true); + + return f; + } +} diff --git a/gl4java/awt/GLAnimCanvas.java b/gl4java/awt/GLAnimCanvas.java new file mode 100644 index 0000000..77fd21f --- /dev/null +++ b/gl4java/awt/GLAnimCanvas.java @@ -0,0 +1,686 @@ +/** + * @(#) GLAnimCanvas.java + */ + +package gl4java.awt; + +import gl4java.GLContext; + +import java.awt.*; +import java.awt.event.*; +import java.lang.Math; + + +/** + * This is meant as an base class writing + * Animations. A clean usage of multi-threading compatible + * with JAVA2 is implemented here ! + * + *

+ * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 

+        The GL4Java Documentation
+ *
+ *

+ * + * This code uses repaint() to fire a sDisplay call by the AWT-Event thread ! + * and sleep to suspend for a given Frames per secounds value as default !! + * + * To switch this behavior for a better performance, and responsiveness + * so that sDisplay is called by the animation thread itself + * call: + * + * 

+        setUseRepaint(false)
+ *
+ *

+ * + * This code sleep's for a given Frames per secounds after each frame + * as default !! + * + * To switch this behavior for a better performance, + * so that much frames are rendered as the machine can do ! + * call: + * + * 

+        setUseFpsSleep(false)
+ *
+ *

+ * But be sure, that the other threads may not have enough time or i + * may not get the cpu power ... + * + * The following settings for setUseRepaint and setUseFpsSleep looks fine: + * + * 

+ 	

+	A JVM with operating system threads has: native-threads
+ 	

+	A JVM where all JVM threads runs in one operating-system-thread
+	has: green-threads
+
+	
+	
+	
+	
+	
+	
green-threadsnative-threads
+	
setUseRepaint
+	true
+	 true & false 
+	
setUseFpsSleep
+	true
+	 true & false 
+
+	

+	
+ *
+ * + * If you play with setUseRepaint or setUseFpsSleep, + * be shure to have a Java VM with native-thread support, + * because a GL-Context can be shared by many threads, + * but one thread can have just one GL-Context ! + * + * (comments welcome) + * + *

+ * To use real fps settings, the following functions provides you to do so: + * 

+        setAnimateFps
+        getMaxFps
+ *
+ * Like the first animation run, this class renders a view frames (default 10) + * to subtract the render time from the sleep time ! + *

+ * You should overwrite the following methods for your needs: + * 

+        init - 1st initialisation
+        display - render one frame
+        reshape - to reshape (window resize)
+        ReInit - ReInitialisation after stop for setSuspended(false)
+ *
+ * + * @see GLCanvas + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLAnimCanvas extends GLCanvas + implements Runnable +{ + /** + * To support frames per scounds, + * instead of killing the machine :-) + * + * A little GUI is supported ! + * + * @see GLAnimCanvas#run + */ + protected double FramesPerSec=20; + protected long mSecPerFrame=0; + + /** + * the delays .. + */ + protected long dFpsMilli = 0; + + /** + * The thread for referencing Thread (Animation) + * + * @see GLAnimCanvas#stop + * @see GLAnimCanvas#start + * @see GLAnimCanvas#run + */ + protected Thread killme = null; + + /** + * Instead of using suspend (JAVA2) + * + * @see GLAnimCanvas#run + */ + protected boolean threadSuspended = false; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLAnimCanvas could not load def. native libs."); + } + + /** + * + * Constructor + * + * @see GLCanvas#GLCanvas + * + */ + public GLAnimCanvas( int width, int height, + String gl_Name, + String glu_Name + ) + { + super( width, height, gl_Name, glu_Name ); + setAnimateFps(FramesPerSec); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @see GLCanvas#GLCanvas + * + */ + public GLAnimCanvas( int width, int height ) + { + super( width, height); + setAnimateFps(FramesPerSec); + } + + /** + * init should be overwritten by you, + * to enter your initialisation code + * + */ + public void init() + { + /* here we should add and initialize our JAVA components */ + + /* ... and furthet OpenGL init's - like you want to */ + + glj.gljCheckGL(); + + ReInit(); + + /* and start our working thread ... */ + start(); + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint, or by the thread directly !). + * The derived-class (Your Subclass) will redefine this, + * to draw it's own animation ! + * + *

+ * + * You should set shallWeRender here, + * to signalize the animation-loop 'run' to supsend + *

+ * To restart the thread, just call setSuspended(false) + * + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLCanvas#sDisplay + * @see GLCanvas#paint + */ + public void display() + { + int i; + + /* Standard GL4Java Init */ + if( cvsIsInit()==false ) + { + if(glj.gljClassDebug) + System.out.println("GLAnimCanvas not initialized yet ..."); + return; + } + + if( glj.gljMakeCurrent(true) == false ) + { + if(glj.gljClassDebug) + System.out.println("GLAnimCanvas problem in gljMakeCurrent() method"); + return; + } + + // ... just render it + + /* For your animation dutys ;-) */ + glj.gljSwap(); + glj.gljCheckGL(); + glj.gljFree(); + } + + /** + * ReInit should be overwritten by you, + * to enter your re-initialisation within setSuspended(false) + * + * @see GLAnimCanvas#setSuspended + */ + public void ReInit() + { + } + + protected boolean useRepaint = true; + + protected boolean useFpsSleep = true; + + /** + * The normal behavior is to use 'repaint' + * within the AWT-Event Thread to render. + *

+ * If you have serious reasons, e.g. measuring performance, + * you can change it while invoke this function with 'false'. + * In this case, the thread itself calls the sDisplay method ! + * + * On fast good multi-threading machines (native-thread-JVM), + * this should increase the performance and the responsiveness ! + *

+ * + * @param b if true, uses repaint (default), otherwise directly sDisplay + * @see GLCanvas#sDisplay + * @see GLAnimCanvas#setUseFpsSleep + */ + public void setUseRepaint(boolean b) + { + useRepaint = b; + } + + /** + * The normal behavior is to use FpsSleep + * + * But you can overwrite this behavior and + * drop the Frame Per Secound sleeps - + * so that much frames are rendered as the machine can do ! + *

+ * + * @param b if true, uses Fps sleeping, else not ! + * @see GLCanvas#sDisplay + * @see GLAnimCanvas#setUseRepaint + */ + public void setUseFpsSleep(boolean b) + { + useFpsSleep = b; + } + + public boolean getUseRepaint() + { + return useRepaint; + } + + public boolean getUseFpsSleep() + { + return useFpsSleep; + } + + /** + * HERE WE DO HAVE OUR RUNNING THREAD ! + * WE NEED STUFF LIKE THAT FOR ANIMATION ;-) + */ + public void start() + { + if(killme == null) + { + killme = new Thread(this); + killme.start(); + + resetFpsCounter(); + } + } + + public synchronized void stop() + { + killme = null; + threadSuspended=false; + notify(); + } + + /** + * Should be set in display, + * whether to render or not while the animation loop + *

+ * If shallWeRender is false, + * this thread will suspend ! + * + * @see GLAnimCanvas#display + * @see GLAnimCanvas#run + */ + protected boolean shallWeRender = true; + + private long _fDelay = 0; + private long _fDelay_Frames = 10; + private boolean _fDelaySync=true; + private boolean _fDelayRun=false; + + /** + * The running loop for animations + * which initiates the call of display + * + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#display + * @see GLAnimCanvas#diplay + */ + public void run() + { + Thread thisThread = Thread.currentThread(); + + + while (killme==thisThread) + { + if(cvsIsInit()) + { + /* DRAW THE TINGS .. */ + if (shallWeRender) + { + if(useRepaint) + repaint(); + else + sDisplay(); + } else { + // lets sleep ... + synchronized (this) { + threadSuspended=true; + } + } + + if(fps_isCounting) + fps_frames++; + + } + + try { + if(useFpsSleep) + { + if(useRepaint) + { + if(mSecPerFrame<_f_dur) + dFpsMilli=_f_dur; + else + dFpsMilli=mSecPerFrame; + } + else + { + dFpsMilli= mSecPerFrame - _f_dur; + if (dFpsMilli<=0) + dFpsMilli= 1; + } + + Thread.currentThread().sleep(dFpsMilli, 0 ); + } + + if (threadSuspended) { + stopFpsCounter(); + synchronized (this) { + while (threadSuspended) + wait(); + } + } + } catch (InterruptedException e) + {} + } + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @see GLAnimCanvas#isAlive + * @see GLAnimCanvas#start + */ + public void setSuspended(boolean suspend) + { + setSuspended(suspend, false); + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @param reInit if true the ReInit will be called additionally, + * where the user can set additional initialisations + * + * @see GLAnimCanvas#isAlive + * @see GLAnimCanvas#start + */ + public synchronized void setSuspended(boolean suspend, boolean reInit) + { + if(suspend) { + shallWeRender=false; + } else if(isAlive()==false) { + start(); + } else { + // the thread is alive, but suspended and should be + // re-started + shallWeRender=true; + resetFpsCounter(); + + if(reInit) + ReInit(); + + threadSuspended=false; + notify(); + } + } + + /** + * is the thread alive, means is started and not died ? + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#start + * @see GLAnimCanvas#stop + */ + public boolean isAlive() + { + if(killme==null) return false; + return killme.isAlive(); + } + + /** + * is the thread suspended, means is started but waiting, + * or not alive (ok :-| - but it is practical) + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#start + * @see GLAnimCanvas#stop + */ + public boolean isSuspended() + { + if(killme==null) return true; + return threadSuspended; + } + + private double fps=0; // frame-per-sec + private long fps_duration =0; // milli-secs + private long fps_start=0; // milli-secs + private long fps_frames =0; // number of frames + private boolean fps_isCounting =true; // shall i count + private boolean verboseFps =false; // shall i be verbose + + /** + * resets the Fps Counter + *

+ * this function is called automatically by + * start and setSuspended + * + * @see GLAnimCanvas#start + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void resetFpsCounter() + { + fps=0; // frame-per-sec + fps_duration =0; // milli-secs + fps_frames =0; // number of frames + fps_isCounting =true; // shall i count + fps_start=System.currentTimeMillis(); + } + + /** + * stops the Fps Counter and sets all values + * fot the getFps* methods + *

+ * this function is called automatically by + * run, if the thread is suspended via shallWeRender + *

+ * All data's are print out on System.out + * if verboseFps is set ! + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void stopFpsCounter() + { + if(fps_isCounting==true) + { + long fps_end=System.currentTimeMillis(); + fps_duration = fps_end-fps_start; + double timed= ((double)fps_duration)/1000.0; + if(timed==0) timed=1.0; + fps = ((double)fps_frames)/timed ; + fps_isCounting=false; + } + if(verboseFps) + { + System.out.println("\nfps = "+String.valueOf(fps)); + System.out.println("time = "+String.valueOf(fps_duration)+" ms"); + System.out.println("frames = "+String.valueOf(fps_frames)); + if(fps_frames==0) fps_frames=1; + System.out.println("time/f = "+String.valueOf(fps_duration/fps_frames)+" ms"); + } + } + + /** + * sets if the Fps data shall be printed to System.out + * while stopFpsCounter is called ! + *

+ * verboseFps is set to true by default ! + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void setVerboseFps(boolean v) + { + verboseFps=v; + } + + /** + * returns the calculated frames per secounds + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public double getFps() + { + return fps; + } + + /** + * returns the calculated duration in millisecs + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public long getFpsDuration() + { + return fps_duration; + } + + /** + * returns the calculated frames number + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public long getFpsFrames() + { + return fps_frames; + } + + /** + * Just set the FramePerSecounds for Animation + * + * @deprecated Now the frames per seconds are allways + * calculated, no pre-sync needed. + * @see #setAnimateFps(double) + */ + public void setAnimateFps(double fps, int synFrames) + { + setAnimateFps(fps); + } + + /** + * Just set the FramePerSecounds for Animation + * + * @see GLAnimCanvas#getMaxFps + */ + public void setAnimateFps(double fps) + { + FramesPerSec=fps; + mSecPerFrame = (long) ( (1.0/FramesPerSec) * 1000.0 ) ; + if(verboseFps) + { + System.out.println("\nset fps := "+ + String.valueOf(fps)+ + " -> "+String.valueOf(mSecPerFrame)+ + " [ms/frame]" + ); + } + resetFpsCounter(); + } + + /** + * Just get the maximum number of Frames per secounds, + * which is calculated with the time, one frame needs to render ! + * + * this value is avaiable after the thread is started + * and the first frames are rendered ! + * + * @see GLAnimCanvas#setAnimateFps + */ + public double getMaxFps() + { + return (1.0/(double)_f_dur)*1000.0; + } + +} + diff --git a/gl4java/awt/GLCanvas.java b/gl4java/awt/GLCanvas.java new file mode 100644 index 0000000..4a537f9 --- /dev/null +++ b/gl4java/awt/GLCanvas.java @@ -0,0 +1,695 @@ +/** + * @(#) GLCanvas.java + */ + + +package gl4java.awt; + +import gl4java.*; + +import java.awt.*; +import java.awt.event.*; + +/** + * This is meant as an base class writing + * easy render functions. A clean usage of multi-threading compatible + * with JAVA2 is implemented in GLAnimCanvas ! + * + *

+ * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 

+	The GL4Java Documentation
+ *
+ *

+ * + * You should overwrite the following methods for your needs: + * 

+        preInit - initialisation before creating GLContext
+        init - 1st initialisation after creating GLContext
+        doCleanup - OGL cleanup prior to context deletion
+        display - render your frame
+	reshape - to reshape (window resize), gljResize() is allready invoked !
+ *
+ * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * 
+        cvsIsInit
+ *
+ *

+ * IF you remove/release a GLCanvas, + * e.g. you want to close/dispose it´s Window (which contains this GLCanvas), + * you HAVE TO call: + * + * 

+        cvsDispose
+ *
+ * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + *

+ * We do override the following Canvas methods. + * + * 

+        update
+        paint
+ *
+ *

+ * + * @see GLAnimCanvas + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLCanvas extends Canvas + implements GLEnum, GLUEnum, + ComponentListener, WindowListener, MouseListener +{ + protected GLContext glj = null; + public GLFunc gl = null; + public GLUFunc glu = null; + + protected Dimension size = null; + protected boolean mustResize = false; + + protected boolean cvsInitialized=false; + + protected boolean needCvsDispose = false; + + /** + * Visual pre-set for doubleBuffer, default: true + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean doubleBuffer = true; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator buffer size, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * This value has a special behavior. + * For input - within the contructor, + * it is the value for each component ! + * + * The output value, after the constructor returns, + * it is the summary of all accumulation bits of all components ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected int accumSize = 0; + + /** + * Visual pre-set for stereoView, default: false + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean stereoView = false; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean rgba = true; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean createOwnWindow = false; + + /** + * The context with witch display lists and textures will be shared. + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected GLContext sharedGLContext; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLCanvas could not load def. native libs."); + } + + /** + * + * Constructor + * + * @param width the canvas initial-prefered width + * @param height the canvas initial-prefered height + * + * @param gl_Name The name of the GLFunc implementation + * If gl_Name==null, the default class will be used ! + * + * @param glu_Name The name of the GLUFunc implementation + * If gl_LibName==null, the default class will be used ! + * + */ + public GLCanvas( int width, int height, + String gl_Name, + String glu_Name + ) + { + super( ); + + if( (gl=GLContext.createGLFunc(gl_Name)) ==null) + { + System.out.println("GLFunc implementation "+gl_Name+" not created"); + } + if( (glu=GLContext.createGLUFunc(glu_Name)) ==null) + { + System.out.println("GLUFunc implementation "+glu_Name+" not created"); + } + + size = new Dimension(width, height); + + setSize(size); + + /* to be able for RESIZE event's */ + addComponentListener(this); + addMouseListener(this); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param width the canvas initial-prefered width + * @param height the canvas initial-prefered height + * + */ + public GLCanvas( int width, int height ) + { + this(width, height, null, null); + } + + /* GLCanvas AWT classes */ + + public Dimension getPreferredSize() { + return getMinimumSize(); + } + + public Dimension getMinimumSize() { + return size; + } + + /** + * Used to return the created GLContext + */ + public final GLContext getGLContext() { return glj; } + + /** + * + * Overridden update + * This one only call's the paint method, without clearing + * the background - thats hopefully done by OpenGL ;-) + * + * @param g the Graphics Context + * @return void + * + * @see GLCanvas#paint + */ + public void update(Graphics g) + { + /* let's let OpenGL clear the background ... */ + paint(g); + } + + /** + * Safe the toplevel window + */ + protected Window topLevelWindow = null; + + /** + * + * This function returns the found TopLevelWindow, + * which contains this Canvas .. + * + * @return void + * + * @see GLCanvas#paint + */ + public final Window getTopLevelWindow() + { return topLevelWindow; } + + /** + * this function overrides the Canvas paint method ! + * + * For the first paint, + * the user function preInit is called, a GLContext is created + * and the user function init is called ! + * + * Also, if a GL Context exist, GLCanvas's sDisplay-method will be called + * to do OpenGL-rendering. + * + * The sDisplay method itself calls the display-method ! + * sDisplay is needed to be thread-safe, to manage + * the resize functionality and to safe the time per frame. + * + * To define your rendering, you should overwrite the display-method + * in your derivation. + * + * @see gl4java.GLContext#GLContext + * @see GLCanvas#cvsIsInit + * @see GLCanvas#sDisplay + * @see GLCanvas#display + * @see GLCanvas#preInit + * @see GLCanvas#init + */ + public synchronized final void paint( Graphics g ) + { + if(glj == null ) + { + preInit(); + glj = new GLContext ( this, gl, glu, + createOwnWindow, + doubleBuffer, stereoView, + rgba, stencilBits, accumSize, + sharedGLContext ); + + if(glj!=null) + { + createOwnWindow = glj.isOwnWindowCreated(); + doubleBuffer = glj.isDoubleBuffer(); + stencilBits = glj.getStencilBitNumber(); + accumSize = glj.getAccumSize(); + stereoView = glj.isStereoView(); + rgba = glj.isRGBA(); + } + + init(); + + // fetch the top-level window , + // to add us as the windowListener + // + Container _c = getParent(); + Container c = null; + + while(_c!=null) + { + c = _c; + _c = _c.getParent(); + } + + if(c instanceof Window) { + topLevelWindow = (Window)c; + topLevelWindow.addComponentListener(this); + } else { + topLevelWindow = null; + System.out.println("toplevel is not a Window: "+c); + } + + if(topLevelWindow!=null) + { + topLevelWindow.addWindowListener(this); + } else { + System.out.println("no parent found for "+getName()); + System.out.flush(); + } + if(glj!=null && glj.gljIsInit()) + cvsInitialized=true; + } + /* + if( mustResize ) size = getSize(); + g.setClip(0, 0, size.width, size.height ) ; + */ + sDisplay(); + } + + /** + * + * This is your pre-init method. + * preInit is called just BEFORE the GL-Context is created. + * You should override preInit, to initialize your visual-stuff, + * like the protected vars: doubleBuffer and stereoView + * + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#doubleBuffer + * @see GLCanvas#stereoView + * @see GLCanvas#rgba + * @see GLCanvas#stencilBits + * @see GLCanvas#accumSize + */ + public void preInit() + { + } + + /** + * + * This is your init method. + * init is called right after the GL-Context is initialized. + * You should override init, to initialize your stuff needed + * by OpenGL an Java ! + * + * @return void + * + * @see GLCanvas#paint + */ + public void init() + { + } + + /** + * This method is used to clean up any OpenGL stuff (delete textures + * or whatever) prior to actually deleting the OpenGL context. + * You should override this with your own version, if you need to do + * any cleanup work at this phase. + * This functions is called within cvsDispose + * + * @return void + * + * @see GLCanvas#cvsDispose + */ + public void doCleanup() + { + } + + /** + * This function returns, if everything is init: the GLContext, + * the and the users init function + * This value is set in the paint method! + * + * @return boolean + * + * @see GLCanvas#paint + * @see GLCanvas#init + */ + public boolean cvsIsInit() + { + return cvsInitialized; + } + + protected long _f_dur = 0; + + /** + * + * This is the thread save rendering-method called by paint. + * The actual thread will be set to highes priority befor calling + * 'display'. After 'display' the priority will be reset ! + * + * 'gljFree' will be NOT called after 'display'. + * + * We tested the above to use multi-threading and + * for the demonstration 'glDemos' it works ;-)) ! + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay -- OR YOU MUST KNOW WHAT YOU ARE DOING THEN ! + * + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#display + */ + public synchronized final void sDisplay() + { + boolean ok = true; + + long _s = System.currentTimeMillis(); + + if(!cvsIsInit()) + return; + + if( mustResize ) + { + if( (ok = glj.gljMakeCurrent()) == true ) + { + size = getSize(); + glj.gljResize( size.width, size.height ) ; + reshape(size.width, size.height); + mustResize = false; + invalidate(); + repaint(100); + } + } + if(ok) + { + display(); + } + + _f_dur = System.currentTimeMillis()-_s; + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint !). + * The derived-class (Your Subclass) will redefine this, to draw it's own... + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay ! + * + * 'sDisplay' manages a semaphore to avoid reentrance of + * the display function !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @return void + * + * @see GLCanvas#sDisplay + * @see GLCanvas#paint + */ + public void display() + { + } + + /** + * + * This is the reshape-method called by paint. + * The derived-class (Your Subclass) will redefine this, + * to manage your individual reshape ... + * + * This ´reshape´ method will be invoked after the first paint command + * after GLCanvas.componentResize is called AND only if ´gljUse´ was + * succesfull (so a call of gljUse is redundant). + * ´reshape´ is not an overloading of java.awt.Component.reshape, + * ´reshape´ is more like ´glut´-reshape. + * + * GLCanvas.reshape allready has a simple default implementation, + * which calls ´gljResize´ and ´glViewport´ - so you may be can + * left this one as it is (no need to overload). + * The needed call to ´gljResize´ is done by hte invoker paint ! + * + * @param width the new width + * @param height the new height + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#sDisplay + */ + public void reshape( int width, int height ) + { + gl.glViewport(0,0, width, height); + } + + /** + * + * ´componentResized´ is the componentListeners event handler. + * + * This method sets the variable ´mustResize´ to true, + * so the upcoming ´paint´ method-call will invoke ´reshape´ ! + * + * This little look-alike complicating thing is done, + * to avoid an Exception by using the glContext from more than + * one concurrent thread´s ! + * + * You cannot override this implementation, it is final + * - override ´reshape' instead ! + * + * @param e the element, which is resized + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#reshape + */ + public void componentResized(ComponentEvent e) + { + if(glj!=null && glj.gljIsInit() && e.getComponent()==this ) + { + mustResize = true; + repaint(); + } + } + + public void componentMoved(ComponentEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(100); + } + } + + public void componentShown(ComponentEvent e) + { + } + + public void componentHidden(ComponentEvent e) + { } + + public void mouseClicked(MouseEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(); + } + } + + public void mouseEntered(MouseEvent e) + { } + public void mouseExited(MouseEvent e) + {} + public void mousePressed(MouseEvent e) + { + } + public void mouseReleased(MouseEvent e) + { + } + + public void windowOpened(WindowEvent e) + { + } + + /** + * + * ´windowClosing´ is the windowListeners event handler + * for the topLevelWindow of this Canvas ! + * + * This methods free´s AND destroy´s + * the GL Context with ´glj.gljDestroy´ ! + * + * @return void + * + */ + public void windowClosing(WindowEvent e) + { + if(e.getComponent().equals(topLevelWindow)) + { + cvsDispose(); + } + } + + /** + * + * ´windowClosed´ is the windowListeners event handler. + * + * @return void + * + */ + public void windowClosed(WindowEvent e) + { + if (needCvsDispose) cvsDispose(); + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(100); + } + } + + public void windowDeactivated(WindowEvent e) + { + } + + /** + * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + * This function calls gljDestroy of GLContext ! + * + * @see gl4java.GLContext#gljDestroy + * @see GLCanvas#doCleanup + */ + public void cvsDispose() + { + cvsInitialized = false; + if (glj != null) + { + if (glj.gljIsInit()) + { + /* Sometimes the Microsoft VM calls the + Applet.stop() method but doesn't have + permissions to do J/Direct calls, so + this whole block of code will throw a + security exception. If this happens, + however, windowClosing() will still + call us again later and we will have + another opportunity to shut down the + context, so it all works out fine. */ + try + { + glj.gljFree(); + doCleanup(); + //locks and free's GLContext + glj.setEnabled(false); + glj.gljDestroy(); + needCvsDispose = false; + } + catch (Exception ex) + { + needCvsDispose = true; + } + } + } + + // Setting glj to null will simply cause paint() to re-initialize. + // We don't want that to happen, so we will leave glj non-null. + } + + /** + * get methods + */ + public final int cvsGetWidth() { + return getSize().width; + } + public final int cvsGetHeight() { + return getSize().height; + } +} + diff --git a/gl4java/awt/GLImageCanvas.java b/gl4java/awt/GLImageCanvas.java new file mode 100755 index 0000000..113d589 --- /dev/null +++ b/gl4java/awt/GLImageCanvas.java @@ -0,0 +1,402 @@ +/** + * @(#) GLImageCanvas.java + */ + + +package gl4java.awt; + +import gl4java.*; +import gl4java.utils.*; +import gl4java.utils.textures.*; + +import java.awt.*; +import java.net.*; + +/** + * This Class provides a simple universal + * Image/Texture OpenGL Canvas ! + * + * A special demo/application for this class can be found + * in "demos/MiscDemos/GLImageViewerCanvas.java" ! + * + * @see TextureLoader + * @author Sven Goethel + * + */ +public class GLImageCanvas extends GLCanvas +{ + int texName[] = {0}; + TextureLoader txtLoader = null; + boolean newText = false; + boolean keepAspect = true; + boolean zoomImg = true; + + TextureGrabber textGrab4Snapshot = null; + String textGrab4SnapshotFName = null; + URL textGrab4SnapshotURL = null; + String textGrab4SnapshotURI = null; + + public GLImageCanvas(int w, int h) + { + super(w, h); + } + + public void setKeepAspectRatio(boolean v) + { keepAspect=v; } + + public boolean getKeepAspectRatio() + { return keepAspect; } + + public void setZoomAble(boolean v) + { zoomImg = v; } + + public boolean getZoomAble() + { return zoomImg; } + + public TextureLoader getTextureLoader() + { return txtLoader; } + + public void setOriginalSize() + { + if(txtLoader!=null && txtLoader.isOk()) + { + internalSetSize( txtLoader.getImageWidth(), + txtLoader.getImageHeight() ); + } + } + + /** + * Creates a snapshot (save texture/image) of the current + * GL-Context ! + * + * The snapshot itself is created delayed, + * so no return value is avaiable. + * Because this is a non critical path, I hope its enough ! + * + * @param tg The TextureGrabber + * @param fname The filename + * @see TextureGrabber + */ + public void snapshot(TextureGrabber tg, String fname) + { + textGrab4Snapshot=tg; + textGrab4SnapshotFName=fname; + repaint(); + } + + /** + * Creates a snapshot (save texture/image) of the current + * GL-Context ! + * + * The snapshot itself is created delayed, + * so no return value is avaiable. + * Because this is a non critical path, I hope its enough ! + * + * @param tg The TextureGrabber + * @param base The base URL + * @param uri The additional uri for the base URL + * @see TextureGrabber + */ + public void snapshot(TextureGrabber tg, URL base, String uri) + { + textGrab4Snapshot=tg; + textGrab4SnapshotURL = base; + textGrab4SnapshotURI = uri; + repaint(); + } + + public Dimension getPreferredSize() { + return getMinimumSize(); + } + + public Dimension getMinimumSize() { + return getSize(); + } + + protected void internalSetSize(int w, int h) + { + setSize( w, h ); + invalidate(); + + Window holder = Tool.getWindow(this); + + if(holder!=null) + { + holder.invalidate(); + holder.pack(); + holder.repaint(); + } + } + + public void preInit() + { + // createOwnWindow = true; + } + + public void init() + { + gl.glEnable(GL_TEXTURE_2D); + + gl.glGenTextures(1,texName); + gl.glBindTexture(GL_TEXTURE_2D,texName[0]); + + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + gl.glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + gl.glShadeModel (GL_SMOOTH); + + gl.glClearColor(0.2f, 0.2f, 0.2f, 1.0f); + + reshape(getSize().width, getSize().height); + } + + /** + * Loads an Image of the appropiate type, + * and renders and resizes the complete window ! + * + * @param fname The filename + * @param type The type of file, e.g. TextureLoader is used ! + * The following types are currently allowed: + * "png" for PngTextureLoader, + * "ppm" for PPMAsciiTextureLoader, + * "tga" for PPMAsciiTextureLoader, + * "any" for AWTTextureLoader ! + */ + public boolean loadTexture(String fname, String type) + { + return loadTexture(fname, null, null, type); + } + + /** + * Loads an Image of the appropiate type, + * and renders and resizes the complete window ! + * + * @param base The base URL + * @param uri The additional uri for the base URL + * @param type The type of file, e.g. TextureLoader is used ! + * The following types are currently allowed: + * "png" for PngTextureLoader, + * "ppm" for PPMAsciiTextureLoader, + * "tga" for PPMAsciiTextureLoader, + * "any" for AWTTextureLoader ! + */ + public boolean loadTexture(URL base, String uri, String type) + { + return loadTexture(null, base, uri, type); + } + + protected boolean loadTexture(String fname, + URL base, String uri, String type) + { + boolean ok = true; + + if( glj.gljMakeCurrent() == false ) + { + System.out.println("problem in use() method"); + return false; + } + + // texture laden + if(type.equals("png")) + txtLoader = new PngTextureLoader(gl, glu); + else if(type.equals("ppm")) + txtLoader = new PPMAsciiTextureLoader(gl, glu); + else if(type.equals("tga")) + txtLoader = new TGATextureLoader(gl, glu); + else if(type.equals("any")) + txtLoader = new AWTTextureLoader(this, gl, glu); + else { + System.out.println("Imagetype: "+type+" is currently not supported !"); + ok = false; + } + + if(ok) + { + try { + if(fname!=null) + txtLoader.readTexture(fname); + else + txtLoader.readTexture(base, uri); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + if(ok && txtLoader.isOk()) + { + gl.glEnable(GL_TEXTURE_2D); + + txtLoader.texImage2DNonScaled(true); + + gl.glDisable(GL_TEXTURE_2D); + System.out.println("texture succesfully loaded !"); + System.out.println("texture: "+txtLoader); + } + glj.gljCheckGL(); + glj.gljFree(); + if(ok) { + internalSetSize( txtLoader.getImageWidth(), + txtLoader.getImageHeight() ); + } + return ok; + } + + public void display() + { + int i; + + /* Standard GL4Java Init */ + if( glj.gljMakeCurrent() == false ) + { + System.out.println("problem in use() method"); + return; + } + + SetCamera(); + + // just render it + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + DrawObj(false); + + if(textGrab4Snapshot!=null) + { + textGrab4Snapshot.grabPixels(GL_BACK, + 0, 0, cvsGetWidth(), cvsGetHeight()); + if(textGrab4SnapshotFName!=null) + textGrab4Snapshot.write2File(textGrab4SnapshotFName); + else + textGrab4Snapshot.write2File(textGrab4SnapshotURL, + textGrab4SnapshotURI); + textGrab4Snapshot =null; + textGrab4SnapshotFName=null; + textGrab4SnapshotURL =null; + textGrab4SnapshotURI =null; + } + + /* For your animation dutys ;-) */ + glj.gljSwap(); + glj.gljCheckGL(); + glj.gljFree(); + } + + /** + * to prevent a deadlock in recursive + * reshape .. internalSetSize .. pack .. resize -> reshape ! + */ + private int reshape_resize_sema = 1; + + public void reshape(int w, int h) + { + if(reshape_resize_sema>0 && + keepAspect && txtLoader!=null && txtLoader.isOk()) + { + reshape_resize_sema--; + + int rw=w; int rh=h; + if(zoomImg) + { + double iaspect = (double)txtLoader.getImageWidth()/ + (double)txtLoader.getImageHeight(); + if(rw + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 

+        The GL4Java Documentation
+ *
+ *

+ * + * This code uses repaint() to fire a sDisplay call by the AWT-Event thread ! + * and sleep to suspend for a given Frames per secounds value as default !! + * + * To switch this behavior for a better performance, and responsiveness + * so that sDisplay is called by the animation thread itself + * call: + * + * 

+        setUseRepaint(false)
+ *
+ *

+ * + * This code sleep's for a given Frames per secounds after each frame + * as default !! + * + * To switch this behavior for a better performance, + * so that much frames are rendered as the machine can do ! + * call: + * + * 

+        setUseFpsSleep(false)
+ *
+ *

+ * But be sure, that the other threads may not have enough time or i + * may not get the cpu power ... + * + * The following settings for setUseRepaint and setUseFpsSleep looks fine: + * + * 

+ 	

+	A JVM with operating system threads has: native-threads
+ 	

+	A JVM where all JVM threads runs in one operating-system-thread
+	has: green-threads
+
+	
+	
+	
+	
+	
+	
green-threadsnative-threads
+	
setUseRepaint
+	true
+	 true & false 
+	
setUseFpsSleep
+	true
+	 true & false 
+
+	

+	
+ *
+ * + * If you play with setUseRepaint or setUseFpsSleep, + * be shure to have a Java VM with native-thread support, + * because a GL-Context can be shared by many threads, + * but one thread can have just one GL-Context ! + * + * (comments welcome) + * + *

+ * To use real fps settings, the following functions provides you to do so: + * 

+        setAnimateFps
+        getMaxFps
+ *
+ * Like the first animation run, this class renders a view frames (default 10) + * to subtract the render time from the sleep time ! + *

+ * You should overwrite the following methods for your needs: + * 

+        init - 1st initialisation
+        display - render one frame
+        reshape - to reshape (window resize)
+        ReInit - ReInitialisation after stop for setSuspended(false)
+ *
+ * + * @see GLCanvas + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLAnimJPanel extends GLJPanel + implements Runnable +{ + /** + * To support frames per scounds, + * instead of killing the machine :-) + * + * A little GUI is supported ! + * + * @see GLAnimJPanel#run + */ + protected double FramesPerSec=20; + protected long mSecPerFrame=0; + + /** + * the delays .. + */ + protected long dFpsMilli = 0; + + /** + * The thread for referencing Thread (Animation) + * + * @see GLAnimJPanel#stop + * @see GLAnimJPanel#start + * @see GLAnimJPanel#run + */ + protected Thread killme = null; + + /** + * Instead of using suspend (JAVA2) + * + * @see GLAnimJPanel#run + */ + protected boolean threadSuspended = false; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLAnimJPanel could not load def. native libs."); + } + + /** + * + * Constructor + * + * @param gl_Name The name of the GLFunc implementation + * If gl_Name==null, the default class will be used ! + * + * @param glu_Name The name of the GLUFunc implementation + * If gl_LibName==null, the default class will be used ! + * + * @param layout the layout manager + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLAnimJPanel( String gl_Name, + String glu_Name, + LayoutManager layout, boolean isDoubleBuffered + ) + { + super( gl_Name, glu_Name, layout, isDoubleBuffered ); + setAnimateFps(FramesPerSec); + + } + + /** + * + * Constructor + * + * @param layout the layout manager + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLAnimJPanel( LayoutManager layout, boolean isDoubleBuffered ) + { + super(layout, isDoubleBuffered); + setAnimateFps(FramesPerSec); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + */ + public GLAnimJPanel( boolean isDoubleBuffered ) + { + super(isDoubleBuffered); + setAnimateFps(FramesPerSec); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param layout the layout manager + */ + public GLAnimJPanel(LayoutManager layout) + { + super(layout); + setAnimateFps(FramesPerSec); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @see GLCanvas#GLCanvas + * + */ + public GLAnimJPanel( ) + { + super(); + setAnimateFps(FramesPerSec); + } + + /** + * init should be overwritten by you, + * to enter your initialisation code + * + */ + public void init() + { + /* here we should add and initialize our JAVA components */ + + /* ... and furthet OpenGL init's - like you want to */ + + glj.gljCheckGL(); + + ReInit(); + + /* and start our working thread ... */ + start(); + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint, or by the thread directly !). + * The derived-class (Your Subclass) will redefine this, + * to draw it's own animation ! + * + *

+ * + * You should set shallWeRender here, + * to signalize the animation-loop 'run' to supsend + *

+ * To restart the thread, just call setSuspended(false) + * + * @see GLAnimJPanel#shallWeRender + * @see GLAnimJPanel#run + * @see GLAnimJPanel#setSuspended + * @see GLCanvas#sDisplay + * @see GLCanvas#paint + */ + public void display() + { + int i; + + // ... just render it + + } + + /** + * ReInit should be overwritten by you, + * to enter your re-initialisation within setSuspended(false) + * + * @see GLAnimJPanel#setSuspended + */ + public void ReInit() + { + } + + protected boolean useRepaint = true; + + protected boolean useFpsSleep = true; + + /** + * The normal behavior is to use 'repaint' + * within the AWT-Event Thread to render. + *

+ * If you have serious reasons, e.g. measuring performance, + * you can change it while invoke this function with 'false'. + * In this case, the thread itself calls the sDisplay method ! + * + * On fast good multi-threading machines (native-thread-JVM), + * this should increase the performance and the responsiveness ! + *

+ * + * @param b if true, uses repaint (default), otherwise directly sDisplay + * @see GLCanvas#sDisplay + * @see GLAnimJPanel#setUseFpsSleep + */ + public void setUseRepaint(boolean b) + { + useRepaint = b; + } + + /** + * The normal behavior is to use FpsSleep + * + * But you can overwrite this behavior and + * drop the Frame Per Secound sleeps - + * so that much frames are rendered as the machine can do ! + *

+ * + * @param b if true, uses Fps sleeping, else not ! + * @see GLCanvas#sDisplay + * @see GLAnimJPanel#setUseRepaint + */ + public void setUseFpsSleep(boolean b) + { + useFpsSleep = b; + } + + public boolean getUseRepaint() + { + return useRepaint; + } + + public boolean getUseFpsSleep() + { + return useFpsSleep; + } + + /** + * HERE WE DO HAVE OUR RUNNING THREAD ! + * WE NEED STUFF LIKE THAT FOR ANIMATION ;-) + */ + public void start() + { + if(killme == null) + { + killme = new Thread(this); + killme.start(); + + resetFpsCounter(); + } + } + + public synchronized void stop() + { + killme = null; + threadSuspended=false; + notify(); + } + + /** + * Should be set in display, + * whether to render or not while the animation loop + *

+ * If shallWeRender is false, + * this thread will suspend ! + * + * @see GLAnimJPanel#display + * @see GLAnimJPanel#run + */ + protected boolean shallWeRender = true; + + private long _fDelay = 0; + private long _fDelay_Frames = 10; + private boolean _fDelaySync=true; + private boolean _fDelayRun=false; + + /** + * The running loop for animations + * which initiates the call of display + * + * @see GLAnimJPanel#shallWeRender + * @see GLAnimJPanel#display + * @see GLAnimJPanel#diplay + */ + public void run() + { + Thread thisThread = Thread.currentThread(); + + + while (killme==thisThread) + { + if(cvsIsInit()) + { + /* DRAW THE TINGS .. */ + if (shallWeRender) + { + if(useRepaint) + repaint(); + else + sDisplay(); + } else { + // lets sleep ... + synchronized (this) { + threadSuspended=true; + } + } + + if(fps_isCounting) + fps_frames++; + + } + + try { + if(useFpsSleep) + { + if(useRepaint) + { + if(mSecPerFrame<_f_dur_total) + dFpsMilli=_f_dur_total; + else + dFpsMilli=mSecPerFrame; + } + else + { + dFpsMilli= mSecPerFrame - _f_dur_total; + if (dFpsMilli<=0) + dFpsMilli= 1; + } + + Thread.currentThread().sleep(dFpsMilli, 0 ); + } + + if (threadSuspended) { + stopFpsCounter(); + synchronized (this) { + while (threadSuspended) + wait(); + } + } + } catch (InterruptedException e) + {} + } + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @see GLAnimJPanel#isAlive + * @see GLAnimJPanel#start + */ + public void setSuspended(boolean suspend) + { + setSuspended(suspend, false); + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @param reInit if true the ReInit will be called additionally, + * where the user can set additional initialisations + * + * @see GLAnimJPanel#isAlive + * @see GLAnimJPanel#start + */ + public synchronized void setSuspended(boolean suspend, boolean reInit) + { + if(suspend) { + shallWeRender=false; + } else if(isAlive()==false) { + start(); + } else { + // the thread is alive, but suspended and should be + // re-started + shallWeRender=true; + resetFpsCounter(); + + if(reInit) + ReInit(); + + threadSuspended=false; + notify(); + } + } + + /** + * is the thread alive, means is started and not died ? + * + * @see GLAnimJPanel#run + * @see GLAnimJPanel#setSuspended + * @see GLAnimJPanel#start + * @see GLAnimJPanel#stop + */ + public boolean isAlive() + { + if(killme==null) return false; + return killme.isAlive(); + } + + /** + * is the thread suspended, means is started but waiting, + * or not alive (ok :-| - but it is practical) + * + * @see GLAnimJPanel#run + * @see GLAnimJPanel#setSuspended + * @see GLAnimJPanel#start + * @see GLAnimJPanel#stop + */ + public boolean isSuspended() + { + if(killme==null) return true; + return threadSuspended; + } + + private double fps=0; // frame-per-sec + private long fps_duration =0; // milli-secs + private long fps_start=0; // milli-secs + private long fps_frames =0; // number of frames + private boolean fps_isCounting =true; // shall i count + private boolean verboseFps =true; // shall i be verbose + + /** + * resets the Fps Counter + *

+ * this function is called automatically by + * start and setSuspended + * + * @see GLAnimJPanel#start + * @see GLAnimJPanel#setSuspended + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public void resetFpsCounter() + { + fps=0; // frame-per-sec + fps_duration =0; // milli-secs + fps_frames =0; // number of frames + fps_isCounting =true; // shall i count + fps_start=System.currentTimeMillis(); + } + + /** + * stops the Fps Counter and sets all values + * fot the getFps* methods + *

+ * this function is called automatically by + * run, if the thread is suspended via shallWeRender + *

+ * All data's are print out on System.out + * if verboseFps is set ! + * + * @see GLAnimJPanel#run + * @see GLAnimJPanel#shallWeRender + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public void stopFpsCounter() + { + if(fps_isCounting==true) + { + long fps_end=System.currentTimeMillis(); + fps_duration = fps_end-fps_start; + double timed= ((double)fps_duration)/1000.0; + if(timed==0) timed=1.0; + fps = ((double)fps_frames)/timed ; + fps_isCounting=false; + } + if(verboseFps) + { + System.out.println("\nfps = "+String.valueOf(fps)); + System.out.println("time = "+String.valueOf(fps_duration)+" ms"); + System.out.println("frames = "+String.valueOf(fps_frames)); + if(fps_frames==0) fps_frames=1; + System.out.println("time/f = "+String.valueOf(fps_duration/fps_frames)+" ms"); + } + } + + /** + * sets if the Fps data shall be printed to System.out + * while stopFpsCounter is called ! + *

+ * verboseFps is set to true by default ! + * + * @see GLAnimJPanel#run + * @see GLAnimJPanel#shallWeRender + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public void setVerboseFps(boolean v) + { + verboseFps=v; + } + + /** + * returns the calculated frames per secounds + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public double getFps() + { + return fps; + } + + /** + * returns the calculated duration in millisecs + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public long getFpsDuration() + { + return fps_duration; + } + + /** + * returns the calculated frames number + *

+ * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimJPanel#resetFpsCounter + * @see GLAnimJPanel#stopFpsCounter + * @see GLAnimJPanel#getFps + * @see GLAnimJPanel#getFpsDuration + * @see GLAnimJPanel#getFpsFrames + * @see GLAnimJPanel#setVerboseFps + */ + public long getFpsFrames() + { + return fps_frames; + } + + /** + * Just set the FramePerSecounds for Animation + * + * @deprecated Now the frames per seconds are allways + * calculated, no pre-sync needed. + * @see #setAnimateFps(double) + */ + public void setAnimateFps(double fps, int synFrames) + { + setAnimateFps(fps); + } + + /** + * Just set the FramePerSecounds for Animation + * + * @see GLAnimJPanel#getMaxFps + */ + public void setAnimateFps(double fps) + { + FramesPerSec=fps; + mSecPerFrame = (long) ( (1.0/FramesPerSec) * 1000.0 ) ; + if(verboseFps) + { + System.out.println("\nset fps := "+ + String.valueOf(fps)+ + " -> "+String.valueOf(mSecPerFrame)+ + " [ms/frame]" + ); + } + resetFpsCounter(); + } + + /** + * Just get the maximum number of Frames per secounds, + * which is calculated with the time, one frame needs to render ! + * + * this value is avaiable after the thread is started + * and the first frames are rendered ! + * + * @see GLAnimJPanel#setAnimateFps + */ + public double getMaxFps() + { + return (1.0/(double)_f_dur_total)*1000.0; + } + +} + diff --git a/gl4java/swing/GLJPanel.java b/gl4java/swing/GLJPanel.java new file mode 100644 index 0000000..21beb39 --- /dev/null +++ b/gl4java/swing/GLJPanel.java @@ -0,0 +1,865 @@ +package gl4java.swing; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.event.*; +import javax.swing.*; + +/** + * This is meant as an base class writing + * easy render functions. A clean usage of multi-threading compatible + * with JAVA2 is implemented in GLAnimJPanel ! + * + *

+ * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 

+	The GL4Java Documentation
+ *
+ *

+ * + * You should overwrite the following methods for your needs: + * 

+        preInit - initialisation before creating GLContext
+        init - 1st initialisation after creating GLContext
+        doCleanup - OGL cleanup prior to context deletion
+        display - render your frame
+	reshape - to reshape (window resize), gljResize() is allready invoked !
+ *
+ * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * 
+        cvsIsInit
+ *
+ *

+ * IF you remove/release a GLJPanel, + * e.g. you want to close/dispose it´s Window (which contains this GLJPanel), + * you HAVE TO call: + * + * 

+        cvsDispose
+ *
+ * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + *

+ * We do override the following Canvas methods. + * + * 

+        update
+        paint
+ *
+ *

+ * + * @see GLAnimJPanel + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLJPanel extends JPanel + implements GLEnum, GLUEnum, + ComponentListener, WindowListener, MouseListener +{ + protected GLContext glj = null; + public GLFunc gl = null; + public GLUFunc glu = null; + + protected boolean mustResize = false; + + protected boolean cvsInitialized=false; + + protected boolean needCvsDispose = false; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLJPanel#preInit + * @see GLJPanel#paint + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator buffer size, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLJPanel#preInit + * @see GLJPanel#paint + */ + protected int accumSize = 0; + + /** + * Visual pre-set for stereoView, default: false + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLJPanel#preInit + * @see GLJPanel#paint + */ + protected boolean stereoView = false; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLJPanel#preInit + * @see GLJPanel#paint + */ + protected boolean rgba = true; + + /** + * The context with witch display lists and textures will be shared. + * + * @see GLJPanel#preInit + * @see GLJPanel#paint + */ + protected GLContext sharedGLContext; + + /** + * The data to hold the offscreen pixels on the java side ! + * + * @see GLJPanel#offImagePixels + * @see GLJPanel#paint + */ + protected BufferedImage offImage = null; + + /** + * The data to hold the offscreen pixels on the GL side ! + * + * @see GLJPanel#offImage + * @see GLJPanel#paint + */ + protected byte[] offImagePixels = null; + + /** + * The custom set offscreen Size + * + * If this is set to != null, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @see GLJPanel#paint + * @see GLJPanel#setOffScreenSize + * @see GLJPanel#getOffScreenSize + */ + protected Dimension offScrnSize = null; + protected boolean customOffScrnSize=false; + protected boolean offScrnSizeChanged=false; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLJPanel could not load def. native libs."); + } + + /** + * + * Constructor + * + * @param gl_Name The name of the GLFunc implementation + * If gl_Name==null, the default class will be used ! + * + * @param glu_Name The name of the GLUFunc implementation + * If gl_LibName==null, the default class will be used ! + * + * @param layout the layout manager + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLJPanel( String gl_Name, + String glu_Name, + LayoutManager layout, boolean isDoubleBuffered + ) + { + super( layout, isDoubleBuffered ); + + if( (gl=GLContext.createGLFunc(gl_Name)) ==null) + { + System.out.println("GLFunc implementation "+gl_Name+" not created"); + } + if( (glu=GLContext.createGLUFunc(glu_Name)) ==null) + { + System.out.println("GLUFunc implementation "+glu_Name+" not created"); + } + + /* to be able for RESIZE event's */ + addComponentListener(this); + + setOpaque(false); + } + + /** + * + * Constructor + * + * @param layout the layout manager + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLJPanel( LayoutManager layout, boolean isDoubleBuffered ) + { + this(null, null, layout, isDoubleBuffered); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param isDoubleBuffered the flag indicates, + * if double buffer should be used + */ + public GLJPanel( boolean isDoubleBuffered ) + { + this(null, null, new FlowLayout(), isDoubleBuffered); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param layout the layout manager + */ + public GLJPanel(LayoutManager layout) + { + this(null, null, layout, true); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + */ + public GLJPanel( ) + { + this(null, null, new FlowLayout(), true); + } + + /** + * Used to return the created GLContext + */ + public final GLContext getGLContext() { return glj; } + + /** + * Safe the toplevel window + */ + protected Window topLevelWindow = null; + + /** + * + * This function returns the found TopLevelWindow, + * which contains this Canvas .. + * + * @return void + * + * @see GLJPanel#paint + */ + public final Window getTopLevelWindow() + { return topLevelWindow; } + + /** + * The customers offscreen Size + * + * If this is set, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @see GLJPanel#offScrnSize + * @see GLJPanel#setOffScreenSize + */ + public Dimension getOffScreenSize() + { return offScrnSize; } + + /** + * The customers offscreen Size + * + * If this is set, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @see GLJPanel#offScrnSize + * @see GLJPanel#getOffScreenSize + */ + public void setOffScreenSize(Dimension size) + { + if((size!=null && size.equals(offScrnSize)==false) || + size!=offScrnSize + ) + { + offScrnSizeChanged=true; + offScrnSize=size; + customOffScrnSize=offScrnSize!=null; + } + } + + /** + * this function overrides the Canvas paint method ! + * + * For the first paint, + * the user function preInit is called, a GLContext is created + * and the user function init is called ! + * + * Also, if a GL Context exist, GLJPanel's sDisplay-method will be called + * to do OpenGL-rendering. + * + * The sDisplay method itself calls the display-method ! + * sDisplay is needed to be thread-safe, to manage + * the resize functionality and to safe the time per frame. + * + * To define your rendering, you should overwrite the display-method + * in your derivation. + * + * @see gl4java.GLContext#GLContext + * @see GLJPanel#cvsIsInit + * @see GLJPanel#sDisplay + * @see GLJPanel#display + * @see GLJPanel#preInit + * @see GLJPanel#init + */ + public synchronized final void paintComponent(Graphics g) + { + if(glj == null || + (mustResize && !customOffScrnSize) || offScrnSizeChanged ) + { + if(mustResize) + { + cvsDispose(); + mustResize=false; + } + preInit(); + glj = GLContext.createOffScreenCtx ( this, gl, glu, + stereoView, + rgba, stencilBits, accumSize, + sharedGLContext, + offScrnSize + ); + + if(glj!=null) + { + /* + createOwnWindow = glj.isOwnWindowCreated(); + doubleBuffer = glj.isDoubleBuffer(); + */ + stencilBits = glj.getStencilBitNumber(); + accumSize = glj.getAccumSize(); + stereoView = glj.isStereoView(); + rgba = glj.isRGBA(); + } + if(offImage!=null) + offImage.flush(); + offImage=null; + offScrnSizeChanged=false; + + init(); + + // fetch the top-level window , + // to add us as the windowListener + // + Container _c = getParent(); + Container c = null; + + while(_c!=null) + { + c = _c; + _c = _c.getParent(); + } + + if(c instanceof Window) { + topLevelWindow = (Window)c; + topLevelWindow.addComponentListener(this); + topLevelWindow.addMouseListener(this); + } else { + topLevelWindow = null; + System.out.println("toplevel is not a Window: "+c); + } + + if(topLevelWindow!=null) + { + topLevelWindow.addWindowListener(this); + } else { + System.out.println("no parent found for "+getName()); + System.out.flush(); + } + if(glj!=null && glj.gljIsInit()) + cvsInitialized=true; + } + /* + if( mustResize ) size = getSize(); + g.setClip(0, 0, size.width, size.height ); + */ + //super.paintComponent(g); + + gr = g; + sDisplay(); + } + + Graphics gr = null; + DataBufferInt dbInt = null; + + /** + * + * This is the thread save rendering-method called by paint. + * The actual thread will be set to highes priority befor calling + * 'display'. After 'display' the priority will be reset ! + * + * 'gljFree' will be NOT called after 'display'. + * + * We tested the above to use multi-threading and + * for the demonstration 'glDemos' it works ;-)) ! + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay -- OR YOU MUST KNOW WHAT YOU ARE DOING THEN ! + * + * @return void + * + * @see GLJPanel#paint + * @see GLJPanel#display + */ + public synchronized final void sDisplay() + { + boolean ok = true; + + long _s = System.currentTimeMillis(); + + if(!cvsIsInit()) + return; + + if( glj.gljMakeCurrent() == false ) { + System.out.println("GLJPanel: problem in use() method"); + return; + } + + if(ok) + { + display(); + _f_dur_self = System.currentTimeMillis()-_s; + if(GLContext.gljClassDebug) + { + _f_dur_self_sum+=_f_dur_self; + glj.gljCheckGL(); + } + + int glFormat; + int glComps; + int awtFormat; + + glFormat = (rgba == true)?GL_RGBA:GL_RGB; + glComps = (rgba == true)?4:3; + awtFormat = (rgba == true)?BufferedImage.TYPE_INT_ARGB: + BufferedImage.TYPE_INT_RGB; + + Dimension size = null; + if(customOffScrnSize) + size=offScrnSize; + else + size=getSize(); + int w=size.width; + int h=size.height; + + long _s_tst = System.currentTimeMillis(); + + if(offImage==null || + offImage.getHeight()!=h || offImage.getWidth()!=w) + { + if(offImage!=null) + offImage.flush(); + offImage = new BufferedImage(w,h,awtFormat); + offImagePixels=new byte[w*h*glComps]; + dbInt = (DataBufferInt) + offImage.getRaster().getDataBuffer(); + + if(GLContext.gljClassDebug) + { + System.out.print("set offImage to size: "+size+ + "(hw size: "+w+"x"+h+"), type: "); + switch(glFormat) { + case GL_RGB: System.out.println("RGB"); break; + case GL_RGBA: System.out.println("RGBA"); break; + case GL_BGR_EXT: System.out.println("BGR"); break; + case GL_BGRA_EXT: System.out.println("BGRA"); break; + } + } + } + + glj.gljReadPixelGL2AWT(0,0,w,h,glFormat,GL_UNSIGNED_BYTE, + glj.isDoubleBuffer()?GL_BACK:GL_FRONT, + offImagePixels, dbInt.getData()); + + //glj.gljSwap(); // no true swapping with offscreen buffers .. + + if(GLContext.gljClassDebug) + _f_dur_tst_sum+=System.currentTimeMillis()-_s_tst; + + if(GLContext.gljClassDebug) + glj.gljCheckGL(); + glj.gljFree(); // enable ctx for threads ... + + if(!customOffScrnSize) + gr.drawImage(offImage, 0, 0, this); + else { + size=super.getSize(); + gr.drawImage(offImage, 0, 0, size.width, size.height, this); + } + + _f_dur_total = System.currentTimeMillis()-_s; + if(GLContext.gljClassDebug) + { + _f_dur_total_sum+=_f_dur_total; + if(++_f_dur_times==100) + { + System.out.println("self p 100: "+ + (double)(_f_dur_self_sum/100)/1000.0+" s"); + + System.out.println("tst p 100: "+ + (double)(_f_dur_tst_sum/100)/1000.0+" s"); + + System.out.println("gl-bitblit p 100: "+ + (double)((_f_dur_total_sum-_f_dur_self_sum)/100)/1000.0+" s"); + System.out.println("total p 100: "+ + (double)(_f_dur_total_sum/100)/1000.0+" s"); + + _f_dur_self_sum=0; + _f_dur_tst_sum=0; + _f_dur_total_sum=0; + _f_dur_times=0; + } + } + + } + + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint !). + * The derived-class (Your Subclass) will redefine this, to draw it's own... + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay ! + * + * 'sDisplay' manages a semaphore to avoid reentrance of + * the display function !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @return void + * + * @see GLJPanel#sDisplay + * @see GLJPanel#paint + */ + public void display() + { + } + + /** + * + * This is your pre-init method. + * preInit is called just BEFORE the GL-Context is created. + * You should override preInit, to initialize your visual-stuff, + * like the protected vars: doubleBuffer and stereoView + * + * @return void + * + * @see GLJPanel#paint + * @see GLJPanel#doubleBuffer + * @see GLJPanel#stereoView + * @see GLJPanel#rgba + * @see GLJPanel#stencilBits + * @see GLJPanel#accumSize + */ + public void preInit() + { + } + + /** + * + * This is your init method. + * init is called right after the GL-Context is initialized. + * You should override init, to initialize your stuff needed + * by OpenGL an Java ! + * + * @return void + * + * @see GLJPanel#paint + */ + public void init() + { + } + + /** + * This method is used to clean up any OpenGL stuff (delete textures + * or whatever) prior to actually deleting the OpenGL context. + * You should override this with your own version, if you need to do + * any cleanup work at this phase. + * This functions is called within cvsDispose + * + * @return void + * + * @see GLJPanel#cvsDispose + */ + public void doCleanup() + { + } + + /** + * This function returns, if everything is init: the GLContext, + * the and the users init function + * This value is set in the paint method! + * + * @return boolean + * + * @see GLJPanel#paint + * @see GLJPanel#init + */ + public boolean cvsIsInit() + { + return cvsInitialized; + } + + protected long _f_dur_self = 0; + protected long _f_dur_self_sum = 0; + protected long _f_dur_tst_sum = 0; + protected long _f_dur_total = 0; + protected long _f_dur_total_sum = 0; + protected int _f_dur_times = 0; + + /** + * + * This is the reshape-method called by paint. + * The derived-class (Your Subclass) will redefine this, + * to manage your individual reshape ... + * + * This ´reshape´ method will be invoked after the first paint command + * after GLJPanel.componentResize is called AND only if ´gljUse´ was + * succesfull (so a call of gljUse is redundant). + * ´reshape´ is not an overloading of java.awt.Component.reshape, + * ´reshape´ is more like ´glut´-reshape. + * + * GLJPanel.reshape allready has a simple default implementation, + * which calls ´gljResize´ and ´glViewport´ - so you may be can + * left this one as it is (no need to overload). + * The needed call to ´gljResize´ is done by hte invoker paint ! + * + * @param width the new width + * @param height the new height + * @return void + * + * @see GLJPanel#paint + * @see GLJPanel#sDisplay + */ + public void reshape( int width, int height ) + { + if(GLContext.gljClassDebug) + System.out.println("GLJPanel::reshape bounds("+getBounds()+")"); + gl.glViewport(0,0, width, height); + } + + /** + * + * ´componentResized´ is the componentListeners event handler. + * + * This method sets the variable ´mustResize´ to true, + * so the upcoming ´paint´ method-call will invoke ´reshape´ ! + * + * This little look-alike complicating thing is done, + * to avoid an Exception by using the glContext from more than + * one concurrent thread´s ! + * + * You cannot override this implementation, it is final + * - override ´reshape' instead ! + * + * @param e the element, which is resized + * @return void + * + * @see GLJPanel#paint + * @see GLJPanel#reshape + */ + public void componentResized(ComponentEvent e) + { + if(GLContext.gljClassDebug) + System.out.println("GLJPanel::componentResized("+e.getComponent()+")"); + if(glj!=null && glj.gljIsInit() && e.getComponent()==this ) + { + mustResize = true; + //repaint(); + } + } + + public void componentMoved(ComponentEvent e) + { + /* + if(GLContext.gljClassDebug) + System.out.print("GLJPanel::componentMoved("+e.getComponent()+")"); + if(e.getComponent().equals(topLevelWindow)) + { + repaint(); + } + */ + } + + public void componentShown(ComponentEvent e) + { + } + + public void componentHidden(ComponentEvent e) + { + } + + public void mouseClicked(MouseEvent e) + { + } + public void mouseEntered(MouseEvent e) + { + /* + if(GLContext.gljClassDebug) + System.out.print("GLJPanel::mouseEntered("+e.getComponent()+")"); + if(e.getComponent().equals(topLevelWindow)) + { + repaint(); + } + */ + } + public void mouseExited(MouseEvent e) + {} + public void mousePressed(MouseEvent e) + { + } + public void mouseReleased(MouseEvent e) + { + } + + public void windowOpened(WindowEvent e) + { + } + + /** + * + * ´windowClosing´ is the windowListeners event handler + * for the topLevelWindow of this Canvas ! + * + * This methods free´s AND destroy´s + * the GL Context with ´glj.gljDestroy´ ! + * + * @return void + * + */ + public void windowClosing(WindowEvent e) + { + if(e.getComponent().equals(topLevelWindow)) + { + cvsDispose(); + } + } + + /** + * + * ´windowClosed´ is the windowListeners event handler. + * + * @return void + * + */ + public void windowClosed(WindowEvent e) + { + if (needCvsDispose) cvsDispose(); + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + } + + public void windowDeactivated(WindowEvent e) + { + } + + /** + * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + * This function calls gljDestroy of GLContext ! + * + * @see gl4java.GLContext#gljDestroy + * @see GLJPanel#doCleanup + */ + public void cvsDispose() + { + cvsInitialized = false; + if (glj != null) + { + if (glj.gljIsInit()) + { + /* Sometimes the Microsoft VM calls the + Applet.stop() method but doesn't have + permissions to do J/Direct calls, so + this whole block of code will throw a + security exception. If this happens, + however, windowClosing() will still + call us again later and we will have + another opportunity to shut down the + context, so it all works out fine. */ + try + { + glj.gljFree(); + doCleanup(); + //locks and free's GLContext + glj.setEnabled(false); + glj.gljDestroy(); + needCvsDispose = false; + } + catch (Exception ex) + { + needCvsDispose = true; + } + } + } + + // Setting glj to null will simply cause paint() to re-initialize. + // We don't want that to happen, so we will leave glj non-null. + } + + public Dimension getSize() + { + if(customOffScrnSize) + return offScrnSize; + return super.getSize(); + } + + /** + * get methods + */ + public final int cvsGetWidth() { + return getSize().width; + } + public final int cvsGetHeight() { + return getSize().height; + } +} + diff --git a/gl4java/swing/GLJPanel.java,v b/gl4java/swing/GLJPanel.java,v new file mode 100644 index 0000000..2d89e6c --- /dev/null +++ b/gl4java/swing/GLJPanel.java,v @@ -0,0 +1,959 @@ +head 1.2; +access; +symbols; +locks; strict; +comment @# @; + + +1.2 +date 2000.07.19.12.08.58; author sven; state Exp; +branches; +next 1.1; + +1.1 +date 2000.07.19.12.01.31; author sven; state Exp; +branches; +next ; + + +desc +@the first - with experimental code +@ + + +1.2 +log +@stabile +@ +text +@package gl4java.swing; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.event.*; +import javax.swing.*; + +/** + * This is meant as an base class writing + * easy render functions. A clean usage of multi-threading compatible + * with JAVA2 is implemented in GLAnimJPanel ! + * + *

+ * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * 

+	The GL4Java Documentation
+ *
+ *

+ * + * You should overwrite the following methods for your needs: + * 

+        preInit - initialisation before creating GLContext
+        init - 1st initialisation after creating GLContext
+        doCleanup - OGL cleanup prior to context deletion
+        display - render your frame
+	reshape - to reshape (window resize), gljResize() is allready invoked !
+ *
+ * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * 
+        cvsIsInit
+ *
+ *

+ * IF you remove/release a GLJPanel, + * e.g. you want to close/dispose it´s Window (which contains this GLJPanel), + * you HAVE TO call: + * + * 

+        cvsDispose
+ *
+ * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + *

+ * We do override the following Canvas methods. + * + * 

+        update
+        paint
+ *
+ *

+ * + * @@see GLAnimJPanel + * @@version 2.0, 21. April 1999 + * @@author Sven Goethel + * + */ +public class GLJPanel extends JPanel + implements GLEnum, GLUEnum, + ComponentListener, WindowListener, MouseListener +{ + protected GLContext glj = null; + public GLFunc gl = null; + public GLUFunc glu = null; + + protected boolean mustResize = false; + + protected boolean cvsInitialized=false; + + protected boolean needCvsDispose = false; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @@see GLJPanel#preInit + * @@see GLJPanel#paint + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator buffer size, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @@see GLJPanel#preInit + * @@see GLJPanel#paint + */ + protected int accumSize = 0; + + /** + * Visual pre-set for stereoView, default: false + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @@see GLJPanel#preInit + * @@see GLJPanel#paint + */ + protected boolean stereoView = false; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @@see GLJPanel#preInit + * @@see GLJPanel#paint + */ + protected boolean rgba = true; + + /** + * The context with witch display lists and textures will be shared. + * + * @@see GLJPanel#preInit + * @@see GLJPanel#paint + */ + protected GLContext sharedGLContext; + + /** + * The data to hold the offscreen pixels on the java side ! + * + * @@see GLJPanel#offImagePixels + * @@see GLJPanel#paint + */ + protected BufferedImage offImage = null; + + /** + * The data to hold the offscreen pixels on the GL side ! + * + * @@see GLJPanel#offImage + * @@see GLJPanel#paint + */ + protected byte[] offImagePixels = null; + + /** + * The custom set offscreen Size + * + * If this is set to != null, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @@see GLJPanel#paint + * @@see GLJPanel#setOffScreenSize + * @@see GLJPanel#getOffScreenSize + */ + protected Dimension offScrnSize = null; + protected boolean customOffScrnSize=false; + protected boolean offScrnSizeChanged=false; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLJPanel could not load def. native libs."); + } + + /** + * + * Constructor + * + * @@param gl_Name The name of the GLFunc implementation + * If gl_Name==null, the default class will be used ! + * + * @@param glu_Name The name of the GLUFunc implementation + * If gl_LibName==null, the default class will be used ! + * + * @@param layout the layout manager + * @@param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLJPanel( String gl_Name, + String glu_Name, + LayoutManager layout, boolean isDoubleBuffered + ) + { + super( layout, isDoubleBuffered ); + + if( (gl=GLContext.createGLFunc(gl_Name)) ==null) + { + System.out.println("GLFunc implementation "+gl_Name+" not created"); + } + if( (glu=GLContext.createGLUFunc(glu_Name)) ==null) + { + System.out.println("GLUFunc implementation "+glu_Name+" not created"); + } + + /* to be able for RESIZE event's */ + addComponentListener(this); + + setOpaque(false); + } + + /** + * + * Constructor + * + * @@param layout the layout manager + * @@param isDoubleBuffered the flag indicates, + * if double buffer should be used + * + */ + public GLJPanel( LayoutManager layout, boolean isDoubleBuffered ) + { + this(null, null, layout, isDoubleBuffered); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @@param isDoubleBuffered the flag indicates, + * if double buffer should be used + */ + public GLJPanel( boolean isDoubleBuffered ) + { + this(null, null, new FlowLayout(), isDoubleBuffered); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @@param layout the layout manager + */ + public GLJPanel(LayoutManager layout) + { + this(null, null, layout, true); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + */ + public GLJPanel( ) + { + this(null, null, new FlowLayout(), true); + } + + /** + * Used to return the created GLContext + */ + public final GLContext getGLContext() { return glj; } + + /** + * Safe the toplevel window + */ + protected Window topLevelWindow = null; + + /** + * + * This function returns the found TopLevelWindow, + * which contains this Canvas .. + * + * @@return void + * + * @@see GLJPanel#paint + */ + public final Window getTopLevelWindow() + { return topLevelWindow; } + + /** + * The customers offscreen Size + * + * If this is set, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @@see GLJPanel#offScrnSize + * @@see GLJPanel#setOffScreenSize + */ + public Dimension getOffScreenSize() + { return offScrnSize; } + + /** + * The customers offscreen Size + * + * If this is set, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * @@see GLJPanel#offScrnSize + * @@see GLJPanel#getOffScreenSize + */ + public void setOffScreenSize(Dimension size) + { + if((size!=null && size.equals(offScrnSize)==false) || + size!=offScrnSize + ) + { + offScrnSizeChanged=true; + offScrnSize=size; + customOffScrnSize=offScrnSize!=null; + } + } + + /** + * this function overrides the Canvas paint method ! + * + * For the first paint, + * the user function preInit is called, a GLContext is created + * and the user function init is called ! + * + * Also, if a GL Context exist, GLJPanel's sDisplay-method will be called + * to do OpenGL-rendering. + * + * The sDisplay method itself calls the display-method ! + * sDisplay is needed to be thread-safe, to manage + * the resize functionality and to safe the time per frame. + * + * To define your rendering, you should overwrite the display-method + * in your derivation. + * + * @@see gl4java.GLContext#GLContext + * @@see GLJPanel#cvsIsInit + * @@see GLJPanel#sDisplay + * @@see GLJPanel#display + * @@see GLJPanel#preInit + * @@see GLJPanel#init + */ + public synchronized final void paintComponent(Graphics g) + { + if(glj == null || + (mustResize && !customOffScrnSize) || offScrnSizeChanged ) + { + if(mustResize) + { + cvsDispose(); + mustResize=false; + } + preInit(); + glj = GLContext.createOffScreenCtx ( this, gl, glu, + stereoView, + rgba, stencilBits, accumSize, + sharedGLContext, + offScrnSize + ); + + if(glj!=null) + { + /* + createOwnWindow = glj.isOwnWindowCreated(); + doubleBuffer = glj.isDoubleBuffer(); + */ + stencilBits = glj.getStencilBitNumber(); + accumSize = glj.getAccumSize(); + stereoView = glj.isStereoView(); + rgba = glj.isRGBA(); + } + if(offImage!=null) + offImage.flush(); + offImage=null; + offScrnSizeChanged=false; + + init(); + + // fetch the top-level window , + // to add us as the windowListener + // + Container _c = getParent(); + Container c = null; + + while(_c!=null) + { + c = _c; + _c = _c.getParent(); + } + + if(c instanceof Window) { + topLevelWindow = (Window)c; + topLevelWindow.addComponentListener(this); + topLevelWindow.addMouseListener(this); + } else { + topLevelWindow = null; + System.out.println("toplevel is not a Window: "+c); + } + + if(topLevelWindow!=null) + { + topLevelWindow.addWindowListener(this); + } else { + System.out.println("no parent found for "+getName()); + System.out.flush(); + } + if(glj!=null && glj.gljIsInit()) + cvsInitialized=true; + } + /* + if( mustResize ) size = getSize(); + g.setClip(0, 0, size.width, size.height ); + */ + //super.paintComponent(g); + + gr = g; + sDisplay(); + } + + Graphics gr = null; + DataBufferInt dbInt = null; + + /** + * + * This is the thread save rendering-method called by paint. + * The actual thread will be set to highes priority befor calling + * 'display'. After 'display' the priority will be reset ! + * + * 'gljFree' will be NOT called after 'display'. + * + * We tested the above to use multi-threading and + * for the demonstration 'glDemos' it works ;-)) ! + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay -- OR YOU MUST KNOW WHAT YOU ARE DOING THEN ! + * + * @@return void + * + * @@see GLJPanel#paint + * @@see GLJPanel#display + */ + public synchronized final void sDisplay() + { + boolean ok = true; + + long _s = System.currentTimeMillis(); + + if(!cvsIsInit()) + return; + + if( glj.gljMakeCurrent() == false ) { + System.out.println("GLJPanel: problem in use() method"); + return; + } + + if(ok) + { + display(); + _f_dur_self = System.currentTimeMillis()-_s; + if(GLContext.gljClassDebug) + { + _f_dur_self_sum+=_f_dur_self; + glj.gljCheckGL(); + } + + int glFormat; + int glComps; + int awtFormat; + + glFormat = (rgba == true)?GL_RGBA:GL_RGB; + glComps = (rgba == true)?4:3; + awtFormat = (rgba == true)?BufferedImage.TYPE_INT_ARGB: + BufferedImage.TYPE_INT_RGB; + + Dimension size = null; + if(customOffScrnSize) + size=offScrnSize; + else + size=getSize(); + int w=size.width; + int h=size.height; + + long _s_tst = System.currentTimeMillis(); + + if(offImage==null || + offImage.getHeight()!=h || offImage.getWidth()!=w) + { + if(offImage!=null) + offImage.flush(); + offImage = new BufferedImage(w,h,awtFormat); + offImagePixels=new byte[w*h*glComps]; + dbInt = (DataBufferInt) + offImage.getRaster().getDataBuffer(); + + if(GLContext.gljClassDebug) + { + System.out.print("set offImage to size: "+size+ + "(hw size: "+w+"x"+h+"), type: "); + switch(glFormat) { + case GL_RGB: System.out.println("RGB"); break; + case GL_RGBA: System.out.println("RGBA"); break; + case GL_BGR_EXT: System.out.println("BGR"); break; + case GL_BGRA_EXT: System.out.println("BGRA"); break; + } + } + } + + glj.gljReadPixelGL2AWT(0,0,w,h,glFormat,GL_UNSIGNED_BYTE, + glj.isDoubleBuffer()?GL_BACK:GL_FRONT, + offImagePixels, dbInt.getData()); + + //glj.gljSwap(); // no true swapping with offscreen buffers .. + + if(GLContext.gljClassDebug) + _f_dur_tst_sum+=System.currentTimeMillis()-_s_tst; + + if(GLContext.gljClassDebug) + glj.gljCheckGL(); + glj.gljFree(); // enable ctx for threads ... + + if(!customOffScrnSize) + gr.drawImage(offImage, 0, 0, this); + else { + size=super.getSize(); + gr.drawImage(offImage, 0, 0, size.width, size.height, this); + } + + _f_dur_total = System.currentTimeMillis()-_s; + if(GLContext.gljClassDebug) + { + _f_dur_total_sum+=_f_dur_total; + if(++_f_dur_times==100) + { + System.out.println("self p 100: "+ + (double)(_f_dur_self_sum/100)/1000.0+" s"); + + System.out.println("tst p 100: "+ + (double)(_f_dur_tst_sum/100)/1000.0+" s"); + + System.out.println("gl-bitblit p 100: "+ + (double)((_f_dur_total_sum-_f_dur_self_sum)/100)/1000.0+" s"); + System.out.println("total p 100: "+ + (double)(_f_dur_total_sum/100)/1000.0+" s"); + + _f_dur_self_sum=0; + _f_dur_tst_sum=0; + _f_dur_total_sum=0; + _f_dur_times=0; + } + } + + } + + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint !). + * The derived-class (Your Subclass) will redefine this, to draw it's own... + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay ! + * + * 'sDisplay' manages a semaphore to avoid reentrance of + * the display function !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @@return void + * + * @@see GLJPanel#sDisplay + * @@see GLJPanel#paint + */ + public void display() + { + } + + /** + * + * This is your pre-init method. + * preInit is called just BEFORE the GL-Context is created. + * You should override preInit, to initialize your visual-stuff, + * like the protected vars: doubleBuffer and stereoView + * + * @@return void + * + * @@see GLJPanel#paint + * @@see GLJPanel#doubleBuffer + * @@see GLJPanel#stereoView + * @@see GLJPanel#rgba + * @@see GLJPanel#stencilBits + * @@see GLJPanel#accumSize + */ + public void preInit() + { + } + + /** + * + * This is your init method. + * init is called right after the GL-Context is initialized. + * You should override init, to initialize your stuff needed + * by OpenGL an Java ! + * + * @@return void + * + * @@see GLJPanel#paint + */ + public void init() + { + } + + /** + * This method is used to clean up any OpenGL stuff (delete textures + * or whatever) prior to actually deleting the OpenGL context. + * You should override this with your own version, if you need to do + * any cleanup work at this phase. + * This functions is called within cvsDispose + * + * @@return void + * + * @@see GLJPanel#cvsDispose + */ + public void doCleanup() + { + } + + /** + * This function returns, if everything is init: the GLContext, + * the and the users init function + * This value is set in the paint method! + * + * @@return boolean + * + * @@see GLJPanel#paint + * @@see GLJPanel#init + */ + public boolean cvsIsInit() + { + return cvsInitialized; + } + + protected long _f_dur_self = 0; + protected long _f_dur_self_sum = 0; + protected long _f_dur_tst_sum = 0; + protected long _f_dur_total = 0; + protected long _f_dur_total_sum = 0; + protected int _f_dur_times = 0; + + /** + * + * This is the reshape-method called by paint. + * The derived-class (Your Subclass) will redefine this, + * to manage your individual reshape ... + * + * This ´reshape´ method will be invoked after the first paint command + * after GLJPanel.componentResize is called AND only if ´gljUse´ was + * succesfull (so a call of gljUse is redundant). + * ´reshape´ is not an overloading of java.awt.Component.reshape, + * ´reshape´ is more like ´glut´-reshape. + * + * GLJPanel.reshape allready has a simple default implementation, + * which calls ´gljResize´ and ´glViewport´ - so you may be can + * left this one as it is (no need to overload). + * The needed call to ´gljResize´ is done by hte invoker paint ! + * + * @@param width the new width + * @@param height the new height + * @@return void + * + * @@see GLJPanel#paint + * @@see GLJPanel#sDisplay + */ + public void reshape( int width, int height ) + { + if(GLContext.gljClassDebug) + System.out.println("GLJPanel::reshape bounds("+getBounds()+")"); + gl.glViewport(0,0, width, height); + } + + /** + * + * ´componentResized´ is the componentListeners event handler. + * + * This method sets the variable ´mustResize´ to true, + * so the upcoming ´paint´ method-call will invoke ´reshape´ ! + * + * This little look-alike complicating thing is done, + * to avoid an Exception by using the glContext from more than + * one concurrent thread´s ! + * + * You cannot override this implementation, it is final + * - override ´reshape' instead ! + * + * @@param e the element, which is resized + * @@return void + * + * @@see GLJPanel#paint + * @@see GLJPanel#reshape + */ + public void componentResized(ComponentEvent e) + { + if(GLContext.gljClassDebug) + System.out.println("GLJPanel::componentResized("+e.getComponent()+")"); + if(glj!=null && glj.gljIsInit() && e.getComponent()==this ) + { + mustResize = true; + //repaint(); + } + } + + public void componentMoved(ComponentEvent e) + { + /* + if(GLContext.gljClassDebug) + System.out.print("GLJPanel::componentMoved("+e.getComponent()+")"); + if(e.getComponent().equals(topLevelWindow)) + { + repaint(); + } + */ + } + + public void componentShown(ComponentEvent e) + { + } + + public void componentHidden(ComponentEvent e) + { + } + + public void mouseClicked(MouseEvent e) + { + } + public void mouseEntered(MouseEvent e) + { + /* + if(GLContext.gljClassDebug) + System.out.print("GLJPanel::mouseEntered("+e.getComponent()+")"); + if(e.getComponent().equals(topLevelWindow)) + { + repaint(); + } + */ + } + public void mouseExited(MouseEvent e) + {} + public void mousePressed(MouseEvent e) + { + } + public void mouseReleased(MouseEvent e) + { + } + + public void windowOpened(WindowEvent e) + { + } + + /** + * + * ´windowClosing´ is the windowListeners event handler + * for the topLevelWindow of this Canvas ! + * + * This methods free´s AND destroy´s + * the GL Context with ´glj.gljDestroy´ ! + * + * @@return void + * + */ + public void windowClosing(WindowEvent e) + { + if(e.getComponent().equals(topLevelWindow)) + { + cvsDispose(); + } + } + + /** + * + * ´windowClosed´ is the windowListeners event handler. + * + * @@return void + * + */ + public void windowClosed(WindowEvent e) + { + if (needCvsDispose) cvsDispose(); + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + } + + public void windowDeactivated(WindowEvent e) + { + } + + /** + * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + * This function calls gljDestroy of GLContext ! + * + * @@see gl4java.GLContext#gljDestroy + * @@see GLJPanel#doCleanup + */ + public void cvsDispose() + { + cvsInitialized = false; + if (glj != null) + { + if (glj.gljIsInit()) + { + /* Sometimes the Microsoft VM calls the + Applet.stop() method but doesn't have + permissions to do J/Direct calls, so + this whole block of code will throw a + security exception. If this happens, + however, windowClosing() will still + call us again later and we will have + another opportunity to shut down the + context, so it all works out fine. */ + try + { + glj.gljFree(); + doCleanup(); + //locks and free's GLContext + glj.setEnabled(false); + glj.gljDestroy(); + needCvsDispose = false; + } + catch (Exception ex) + { + needCvsDispose = true; + } + } + } + + // Setting glj to null will simply cause paint() to re-initialize. + // We don't want that to happen, so we will leave glj non-null. + } + + public Dimension getSize() + { + if(customOffScrnSize) + return offScrnSize; + return super.getSize(); + } + + /** + * get methods + */ + public final int cvsGetWidth() { + return getSize().width; + } + public final int cvsGetHeight() { + return getSize().height; + } +} + +@ + + +1.1 +log +@Initial revision +@ +text +@a414 1 + DataBufferByte dbByte = null; +a438 9 + boolean useBGR = false; + boolean useNativeCpy = false; + + /* + if(glj.getNativeOSType()==GLContext.OsWindoof) + useBGR=true; + if(glj.getNativeOSType()==GLContext.OsX11) + useNativeCpy=true; + */ +d464 3 +a466 10 + if(useBGR) + { + glFormat = (rgba == true)?GL_BGRA_EXT:GL_BGR_EXT; + glComps = (rgba == true)?4:3; + awtFormat = (rgba == true)?BufferedImage.TYPE_4BYTE_ABGR: + BufferedImage.TYPE_3BYTE_BGR; + } else { + glFormat = (rgba == true)?GL_RGBA:GL_RGB; + glComps = (rgba == true)?4:3; + awtFormat = (rgba == true)?BufferedImage.TYPE_INT_ARGB: +a467 1 + } +d485 4 +a488 15 + if(useBGR) + { + offImagePixels=null; + dbByte = (DataBufferByte) + offImage.getRaster().getDataBuffer(); + dbInt = null; + } else { + if(!useNativeCpy) + offImagePixels=new byte[w*h*glComps]; + else + offImagePixels=null; + dbInt = (DataBufferInt) + offImage.getRaster().getDataBuffer(); + dbByte = null; + } +d502 3 +a504 12 + if(useBGR) + glj.gljReadPixelGL2AWT(0,0,w,h,glFormat,GL_UNSIGNED_BYTE, + glj.isDoubleBuffer()?GL_BACK:GL_FRONT, + dbByte.getData()); + else if(useNativeCpy) + { + glj.gljCpyOffScrnImg2Buffer(w, h, glFormat, dbInt.getData()); + glj.gljSwap(); + } else + glj.gljReadPixelGL2AWT(0,0,w,h,glFormat,GL_UNSIGNED_BYTE, + glj.isDoubleBuffer()?GL_BACK:GL_FRONT, + offImagePixels, dbInt.getData()); +@ diff --git a/gl4java/swing/SimpleGLJApplet1.java b/gl4java/swing/SimpleGLJApplet1.java new file mode 100644 index 0000000..0dc21f4 --- /dev/null +++ b/gl4java/swing/SimpleGLJApplet1.java @@ -0,0 +1,292 @@ +/** + * @(#) SimpleGLJApplet1.java + * @(#) author: Sven Goethel + */ + +package gl4java.swing; + +/* This program is licensed under the LGPL */ + +import java.applet.*; +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; +import java.lang.*; +import gl4java.GLContext; +import gl4java.GLFunc; +import gl4java.GLUFunc; +import gl4java.awt.GLAnimCanvas; + +public class SimpleGLJApplet1 extends JApplet + implements MouseListener, WindowListener, ActionListener, ItemListener +{ + public GLJPanel canvas = null; + + public Button buttonInfo = null; + public Button buttonFps = null; + public TextField textFps = null; + public Checkbox checkUseRepaint = null; + public Checkbox checkUseFpsSleep = null; + public Button buttonReStart = null; + + + Frame fInfo = null; + + /* Initialize the applet */ + + public void init() + { + JPanel master = new JPanel (new BorderLayout()); + setContentPane(master); + + JPanel pan = new JPanel(); + pan.setLayout(new GridLayout(2,3)); + + buttonInfo = new Button("GL4Java"); + buttonInfo.addMouseListener(this); + pan.add(buttonInfo); + + checkUseRepaint = new Checkbox("repaint", true); + checkUseRepaint.addItemListener(this); + pan.add(checkUseRepaint); + + checkUseFpsSleep = new Checkbox("fps-sleep", true); + checkUseFpsSleep.addItemListener(this); + pan.add(checkUseFpsSleep); + + buttonReStart = new Button("start/stop"); + buttonReStart.addMouseListener(this); + pan.add(buttonReStart); + + buttonFps = new Button("fps: "); + buttonFps.addMouseListener(this); + pan.add(buttonFps); + + textFps=new TextField("0000000000"); + textFps.addActionListener(this); + pan.add(textFps); + + master.add("South",pan); + } + + + public void start() + { + if(canvas instanceof GLAnimJPanel) + ((GLAnimJPanel)canvas).start(); + } + + + public void stop() + { + if(canvas instanceof GLAnimJPanel) + ((GLAnimJPanel)canvas).stop(); + } + + + public void destroy() + { + if(fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + if(canvas instanceof GLAnimJPanel) + { + ((GLAnimJPanel)canvas).stop(); + ((GLAnimJPanel)canvas).cvsDispose(); + } + } + + + // Methods required for the implementation of MouseListener + public void mouseEntered( MouseEvent evt ) + { + } + + public void mouseExited( MouseEvent evt ) + { + } + + public void mousePressed( MouseEvent evt ) + { + } + + public void mouseReleased( MouseEvent evt ) + { + } + + public void mouseClicked( MouseEvent evt ) + { + Component comp = evt.getComponent(); + + if((canvas instanceof GLAnimJPanel)==false) + return; + + GLAnimJPanel canvasAnim = (GLAnimJPanel)canvas; + + if( canvasAnim!=null && comp.equals(buttonFps) ) + { + double fps = 0; + int a1; + + canvasAnim.stopFpsCounter(); + fps=canvasAnim.getFps(); + a1=(int)(fps*100.0); + fps=(double)a1/100.0; + textFps.setText(String.valueOf(fps)); + canvasAnim.resetFpsCounter(); + } else if( comp.equals(buttonInfo) ) + { + if(fInfo==null && canvasAnim!=null && canvasAnim.getGLContext()!=null) + fInfo = showGLInfo(); + } + else if( comp.equals(buttonReStart) ) + { + canvasAnim.setSuspended(!canvasAnim.isSuspended(), + evt.getClickCount()>1 // -> ReInit + ); + } + } + + public void itemStateChanged( ItemEvent evt ) + { + ItemSelectable comp = evt.getItemSelectable(); + + if((canvas instanceof GLAnimJPanel)==false) + return; + + GLAnimJPanel canvasAnim = (GLAnimJPanel)canvas; + + if( comp.equals(checkUseRepaint ) ) + { + if(canvasAnim!=null) + { + canvasAnim.setUseRepaint(checkUseRepaint.getState()); + System.out.println("canvas uses repaint: "+ + checkUseRepaint.getState()); + } + } + if( comp.equals(checkUseFpsSleep ) ) + { + if(canvasAnim!=null) + { + canvasAnim.setUseFpsSleep(checkUseFpsSleep.getState()); + System.out.println("canvas uses fps-sleep: "+ + checkUseFpsSleep.getState()); + } + } + } + + public void actionPerformed(ActionEvent event) + { + Object source = event.getSource(); + + if((canvas instanceof GLAnimJPanel)==false) + return; + + GLAnimJPanel canvasAnim = (GLAnimJPanel)canvas; + + if ( source == textFps) + { + try { + double FramesPerSec= + Double.valueOf(textFps.getText()).doubleValue(); + if(canvasAnim!=null) + { + canvasAnim.setAnimateFps(FramesPerSec); + canvasAnim.setSuspended(false, true); + } + } catch (NumberFormatException s) { + System.out.println("wrong fps format, use float .."); + } + + } + } + + public void windowOpened(WindowEvent e) + { + } + + public void windowClosing(WindowEvent e) + { + Window w = e.getWindow(); + if(w == fInfo && fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + } + + public void windowClosed(WindowEvent e) + { + Window w = e.getWindow(); + if(w == fInfo && fInfo!=null) + { + fInfo.dispose(); + fInfo=null; + } + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + } + + public void windowDeactivated(WindowEvent e) + { + } + + public Frame showGLInfo() + { + if(canvas==null) return null; + + GLContext glc = canvas.getGLContext(); + if(glc==null) return null; + + GLFunc gl = glc.getGLFunc(); + if(gl==null) return null; + + GLUFunc glu = glc.getGLUFunc(); + if(gl==null) return null; + + if((canvas instanceof GLAnimJPanel)==false) + ((GLAnimJPanel)canvas).setSuspended(true, false); + + Frame f = new Frame("GL4Java Version"); + TextArea info= new TextArea(25, 80); + info.setEditable(false); + f.add(info); + f.setSize(600, 400); + + String str = "null string"; + if( glc.gljMakeCurrent() == false ) + { + str="problem in use() method\n"; + } else { + str=canvas.getGLContext().gljGetVersions(); + if(str==null) + str="could not get versions"; + System.out.println(str); + glc.gljFree(); + } + info.append(str); + + f.addWindowListener(this); + + if((canvas instanceof GLAnimJPanel)==false) + ((GLAnimJPanel)canvas).setSuspended(false, false); + + f.pack(); + f.setVisible(true); + + return f; + } +} diff --git a/gl4java/system/GljMSJDirect.java b/gl4java/system/GljMSJDirect.java new file mode 100644 index 0000000..125d5c0 --- /dev/null +++ b/gl4java/system/GljMSJDirect.java @@ -0,0 +1,77 @@ +/** + * @(#) GljMSJDirect.java + */ + + +package gl4java.system; + +/** + * The base toolkit class for MS-JVM JDirect calls ! + * + * The methods in this class are used by gl4java.GLContext ! + * Because this class MUST compiled with the MS-JVM Java Compiler + * I have decided to put it out of gl4java.GLContext, + * although this can be a security hole ... + * But we must be able to use GL4Java without MS-JVM bytecode. + * + * The Tag @security(checkDllCalls=off) makes us able to + * use these methods outside of these class, + * without a security check all the time. + * The security check is performed at link-time ! + * + * This is the same for gl4java.GLUFuncMSJDirect + * and gl4java.GLFuncMSJDirect ! + * + * @see gl4java.GLContext + * @version 1.00 + * @author Ron Cemer, Sven Goethel + * + */ + +/** @security(checkDllCalls=off) */ +public class GljMSJDirect extends Object +{ + + /* JDirect DLL functions */ + + public static final void OGLWindowMsgPump() + { OGLWindowMsgPumpJDirect(); } + + + /** + * @dll.import("GL4JavaGljMSJDirect") + */ + private static native void OGLWindowMsgPumpJDirect(); + + public static final int createOGLWindowNative(int hwndParent, + int x, int y, + int width, + int height) + { return createOGLWindowNativeJDirect(hwndParent, x,y, width, height); } + + /** + * @dll.import("GL4JavaGljMSJDirect", auto) + */ + private static native int createOGLWindowNativeJDirect(int hwndParent, + int x, int y, + int width, + int height); + + public static final void destroyOGLWindowNative(int hdc) + { destroyOGLWindowNativeJDirect(hdc); } + + /** + * @dll.import("GL4JavaGljMSJDirect") + */ + private static native void destroyOGLWindowNativeJDirect(int hdc); + + public static final void moveOGLWindowNative(int hdc, int x, int y, int width, int height) + { moveOGLWindowNativeJDirect(hdc, x, y, width, height); } + + /** + * @dll.import("GL4JavaGljMSJDirect") + */ + private static native void moveOGLWindowNativeJDirect(int hdc, int x, int y, int width, int height); + +} + diff --git a/gl4java/utils/Test.java b/gl4java/utils/Test.java new file mode 100644 index 0000000..addc706 --- /dev/null +++ b/gl4java/utils/Test.java @@ -0,0 +1,359 @@ +/** + * @(#) Test.java + * @(#) author: Sven Goethel + */ + +package gl4java.utils; + + +/* This program is free software under the license of LGPL */ + +import java.applet.*; +import java.awt.*; +import java.awt.event.*; +import java.lang.*; +import java.util.*; +import java.io.*; +import java.util.*; +import gl4java.GLContext; +import gl4java.awt.GLCanvas; +import gl4java.awt.GLAnimCanvas; +import gl4java.applet.SimpleGLAnimApplet1; + +public class Test +{ + + public Test(String name, Object tstObj, int width, int height) + { + if(tstObj instanceof SimpleGLAnimApplet1) + { + SimpleGLAnimApplet1 glSAnimApplet = (SimpleGLAnimApplet1)tstObj; + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + + glSAnimApplet.setSize(width, height); + glSAnimApplet.init(); + glSAnimApplet.start(); + + f.add(glSAnimApplet); + + Dimension ps = glSAnimApplet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + + } else if(tstObj instanceof GLAnimCanvas) + { + GLAnimCanvas glAnimCvsTest = (GLAnimCanvas)tstObj; + + GLAnimCanvasTest applet = new GLAnimCanvasTest(); + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + f.add("Center", applet); + applet.setSize(width,height); + applet.init(glAnimCvsTest); + applet.start(); + Dimension ps = applet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + + } else { + GLCanvas glCvsTest = (GLCanvas)tstObj; + + GLCanvasTest applet = new GLCanvasTest(); + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + f.add("Center", applet); + applet.setSize(width,height); + applet.init(); + applet.start(); + Dimension ps = applet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + } + } + + /** + * Test to load the native library, GLFunc and GLUFunc implementation ! + * If succesfull, a Frame will created and the GL-Infos (vendor, ...) + * are shown in it ! + * + * @param args, a list of args, + * + * -gljlib gl4java-glj-lib native library + * -gllib gl4java-gl-lib native library + * -glulib gl4java-glu-lib native library + * -glclass gl4java-gl-class java GLFunc implementation + * -gluclass gl4java-glu-class java GLUFunc implementation + * -testclass A derivation of GLCanvas (GLAnimCanvas also) or SimpleGLAnimApplet1 can be started here for testing purposes ! + * -w the testclass window width (default 400) + * -h the testclass window height (default 250) + * -perftest if a derivation of GLAnimCanvas is used as the testclass (see above), the fps-sleep and the use-repaint flags are set to false! + * + * without any arguments, a help screen is shown + */ + public static void main( String args[] ) + { + String gljLibName = null; + String glLibName = null; + String gluLibName = null; + String glName = GLContext.defGLFuncClass; + String gluName = GLContext.defGLUFuncClass; + String testClazzName = GLContext.defGLUFuncClass; + boolean perftest=false; + int width=400, height=250; + int i = 0; + boolean ok=true; + + if(args.length==0) + { + System.out.println("usage: java gl4java.GLContext , where options can be: "); + System.out.println(" -gljlib \t\t\t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib \t\t\t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib \t\t\t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass \t\t\t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass \t\t\t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)"); + System.out.println(" -testclass \t\t\t a derivation of GLCanvas (GLCanvas or GLAnimCanvas) can be started here for testing purposes !"); + System.out.println(" -w \t\t\t the testclass window width (default 800) !"); + System.out.println(" -h \t\t\t the testclass window height (default 600) !"); + System.out.println(" -perftest \t\t\t if a derivation of GLAnimCanvas is used as the testclass (see above), the fps-sleep and the use-repaint flags are set to false!"); + System.exit(0); + } + + while(args.length>i) + { + if(args[i].equals("-gljlib")) { + if(args.length>++i) gljLibName=args[i]; + } else if(args[i].equals("-gllib")) { + if(args.length>++i) glLibName=args[i]; + } else if(args[i].equals("-glulib")) { + if(args.length>++i) gluLibName=args[i]; + } else if(args[i].equals("-glclass")) { + if(args.length>++i) glName=args[i]; + } else if(args[i].equals("-gluclass")) { + if(args.length>++i) gluName=args[i]; + } else if(args[i].equals("-testclass")) { + if(args.length>++i) testClazzName=args[i]; + } else if(args[i].equals("-w")) { + if(args.length>++i) { + try { + width = Integer.valueOf(args[i]).intValue(); + } catch (Exception ex) { + System.out.println("invalid width, please insert an integer value !"); + ok=false; + } + } + } else if(args[i].equals("-h")) { + if(args.length>++i) { + try { + height = Integer.valueOf(args[i]).intValue(); + } catch (Exception ex) { + System.out.println("invalid height, please insert an integer value !"); + ok=false; + } + } + } else if(args[i].equals("-perftest")) { + perftest=true; + } else { + System.out.println("illegal arg "+i+": "+args[i]); + ok=false; + } + i++; + } + + if(!perftest) + { + GLContext.gljNativeDebug = true; + GLContext.gljClassDebug = true; + } else { + GLContext.gljNativeDebug = false; + GLContext.gljClassDebug = false; + } + + if(GLContext.loadNativeLibraries(gljLibName, glLibName, gluLibName)) + System.out.println("native Libraries loaded succesfull"); + else { + System.out.println("native library NOT loaded complete"); + ok=false; + } + + Object tstObj = null; + + if(ok==true) + { + try { + Class canvasClazz = + Class.forName("gl4java.awt.GLCanvas"); + Class animCanvasClazz = + Class.forName("gl4java.awt.GLAnimCanvas"); + Class animAppletCanvasClazz = + Class.forName("gl4java.applet.SimpleGLAnimApplet1"); + + Class tstClazz = + Class.forName(testClazzName); + + if( ! canvasClazz.isAssignableFrom(tstClazz) && + ! animAppletCanvasClazz.isAssignableFrom(tstClazz) ) + { + System.out.println("Your test-clazz is neither derived from gl4java.awt.GLCanvas nor from gl4java.applet.SimpleGLAnimApplet1!"); + ok=false; + throw new Exception(); + } + + /** + * Std. conversion from Integer -> int + */ + Class[] parameterTypes = new Class[4]; + parameterTypes[0] = Class.forName("java.lang.Integer"); + parameterTypes[1] = Class.forName("java.lang.Integer"); + parameterTypes[2] = Class.forName("java.lang.String"); + parameterTypes[3] = Class.forName("java.lang.String"); + + Object[] parameters = null; + java.lang.reflect.Constructor tstObjConstr = null; + + try { + tstObjConstr = tstClazz.getConstructor(parameterTypes); + + parameters = new Object[4]; + parameters[0] = new java.lang.Integer(width); + parameters[1] = new java.lang.Integer(height); + parameters[2] = glName; + parameters[3] = gluName; + + } catch (java.lang.NoSuchMethodException nsme) { + + try { + parameterTypes = new Class[4]; + parameterTypes[0] = Class.forName("java.lang.Integer"); + parameterTypes[1] = Class.forName("java.lang.Integer"); + + tstObjConstr = tstClazz.getConstructor(parameterTypes); + + parameters = new Object[4]; + parameters[0] = new java.lang.Integer(width); + parameters[1] = new java.lang.Integer(height); + + } catch (java.lang.NoSuchMethodException nsme2) { + tstObj = tstClazz.newInstance(); + } + } + + if(tstObj==null && parameters!=null) + tstObj = tstObjConstr.newInstance(parameters); + + } catch (Exception ex) { + System.out.println("Instantiation of: "+testClazzName+" failed !"); + System.out.println(ex); + ok =false; + } + + ok = tstObj!=null ; + } + + if(ok) { + // let's do it ... + Test test = new Test(testClazzName, tstObj, width, height); + } + } + + private class GLAnimCanvasTest extends SimpleGLAnimApplet1 + { + public void init(GLAnimCanvas glAnimCanvas) + { + super.init(); + Dimension d = getSize(); + canvas = glAnimCanvas; + add("Center", canvas); + } + } + + private class GLCanvasTest extends Applet + { + GLCanvas canvas = null; + + /* Initialize the applet */ + + public void init(GLCanvas glCanvas) + { + Dimension d = getSize(); + setLayout(new BorderLayout()); + canvas = glCanvas; + add("Center", canvas); + } + + /* Start the applet */ + + public void start() + { + } + + /* Stop the applet */ + + public void stop() + { + } + } +} diff --git a/gl4java/utils/Tool.java b/gl4java/utils/Tool.java new file mode 100644 index 0000000..e4ef7dc --- /dev/null +++ b/gl4java/utils/Tool.java @@ -0,0 +1,158 @@ +/* + * @(#) Tool.java + * + * @author Sven Goethel + */ + +package gl4java.utils; + +import java.util.*; +import java.lang.*; +import java.net.*; +import java.io.*; +import java.awt.*; +import java.applet.*; + +public class Tool { + +/** + * A few Component methods for Java-VM access + */ + + public static String getVersion() + { + String version = null; + + try { + version = java.lang.System.getProperty("java.version"); + } + catch ( SecurityException s) + { + version=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(version); + } + + return version; + } + + public static String getVendor() + { + String vendor = null; + + try { + vendor = java.lang.System.getProperty("java.vendor"); + } + catch ( SecurityException s) + { + vendor=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(vendor); + } + + return vendor; + + } + + public static String getOSName() + { + String osname = null; + + try { + osname = java.lang.System.getProperty("os.name"); + } + catch ( SecurityException s) + { + osname=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(osname); + } + + return osname; + + } + + public static boolean isNetscapesVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Netscape")>=0; } + + public static boolean isSunsVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Sun")>=0; } + + public static boolean isMicrosoftsVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Microsoft")>=0; } + +/****************************************************************************/ +/****************************************************************************/ +/****************************************************************************/ + +/** + * A few Component methods for easy awt-hierarchy querys + */ + + public static Point getAbsoluteCoord(Component co) + { + Object obj = co; + Point absCoord = co.getLocation(); + Point p = null; + + while (obj instanceof Component) { + Container cont = ((Component)obj).getParent(); + if( cont != null ) { + p = cont.getLocation(); + absCoord.x+=p.x; + absCoord.y+=p.y; + } + if( cont instanceof Window) { + obj=null; + } else obj=cont; + } + return absCoord; + } + + public static Window getWindow(Component co) + { + Window f = null; + Object obj = co; + + while (obj instanceof Component) { + Container cont = ((Component)obj).getParent(); + if( cont instanceof Window) { + f=(Window)cont; + obj=cont; // continue seeking for frame or dialog + } else if( cont instanceof Frame) { + f=(Window)cont; + obj=null; + } else if( cont instanceof Dialog) { + f=(Window)cont; + obj=null; + } else obj=cont; + } + return f; + } + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +/** + * A few find methods to seek for Component(Shadow)s + */ + + + public static boolean isInSameWindow(Component co1, Component co2) + { + if(co1==null || co2==null ) return false; + + Window f1 = getWindow(co1); + Window f2 = getWindow(co2); + + if(f1!=null && f2!=null && f1.equals(f2)) + return true; + + return false; + } + +} + + + diff --git a/gl4java/utils/glut/GLUTEnum.java b/gl4java/utils/glut/GLUTEnum.java new file mode 100644 index 0000000..fb28a88 --- /dev/null +++ b/gl4java/utils/glut/GLUTEnum.java @@ -0,0 +1,40 @@ + +package gl4java.utils.glut; + +public abstract interface GLUTEnum +{ + + static final int GLUT_XLIB_IMPLEMENTATION = 15; + + /* Color index component selection values. */ + static final int GLUT_RED = 0; + static final int GLUT_GREEN = 1; + static final int GLUT_BLUE = 2; + + /* Stroke font constants (use these in GLUT program). */ + static final int GLUT_STROKE_ROMAN = 0; + static final int GLUT_STROKE_MONO_ROMAN = 1; + + /* Bitmap font constants (use these in GLUT program). */ + static final int GLUT_BITMAP_9_BY_15 = 2; + static final int GLUT_BITMAP_8_BY_13 = 3; + static final int GLUT_BITMAP_TIMES_ROMAN_10 = 4; + static final int GLUT_BITMAP_TIMES_ROMAN_24 = 5; + static final int GLUT_BITMAP_HELVETICA_10 = 6; + static final int GLUT_BITMAP_HELVETICA_12 = 7; + static final int GLUT_BITMAP_HELVETICA_18 = 8; + + /* glutVideoResizeGet parameters. */ + static final int GLUT_VIDEO_RESIZE_POSSIBLE = 900; + static final int GLUT_VIDEO_RESIZE_IN_USE = 901; + static final int GLUT_VIDEO_RESIZE_X_DELTA = 902; + static final int GLUT_VIDEO_RESIZE_Y_DELTA = 903; + static final int GLUT_VIDEO_RESIZE_WIDTH_DELTA = 904; + static final int GLUT_VIDEO_RESIZE_HEIGHT_DELTA = 905; + static final int GLUT_VIDEO_RESIZE_X = 906; + static final int GLUT_VIDEO_RESIZE_Y = 907; + static final int GLUT_VIDEO_RESIZE_WIDTH = 908; + static final int GLUT_VIDEO_RESIZE_HEIGHT = 909; +} + + diff --git a/gl4java/utils/glut/GLUTFunc.java b/gl4java/utils/glut/GLUTFunc.java new file mode 100644 index 0000000..fc69d30 --- /dev/null +++ b/gl4java/utils/glut/GLUTFunc.java @@ -0,0 +1,54 @@ + +package gl4java.utils.glut; + +import gl4java.GLFunc; +import gl4java.GLUFunc; + +public interface GLUTFunc +extends GLUTEnum +{ + public void init(GLFunc gl, GLUFunc glu); + + public String glutGetFontDescription(int font); + public void glutBitmapString(int font, String s); + public int glutBitmapWidth(int font, int character); + public void glutStrokeString(int font, String s); + public int glutStrokeWidth(int font, int character); + + public int glutBitmapLength(int font, String string); + public int glutStrokeLength(int font, String string); + + public void glutWireSphere(double radius, int slices, int stacks); + public void glutSolidSphere(double radius, int slices, int stacks); + public void glutWireCone(double base, double height, int slices, int stacks); + public void glutSolidCone(double base, double height, int slices, int stacks); + public void glutWireCube(double size); + public void glutSolidCube(double size); + public void glutWireTorus(double innerRadius, double outerRadius, int sides, int rings); + public void glutSolidTorus(double innerRadius, double outerRadius, int sides, int rings); + public void glutWireDodecahedron(); + public void glutSolidDodecahedron(); + public void glutWireTeapot(double size); + public void glutSolidTeapot(double size); + public void glutWireOctahedron(); + public void glutSolidOctahedron(); + public void glutWireTetrahedron(); + public void glutSolidTetrahedron(); + public void glutWireIcosahedron(); + public void glutSolidIcosahedron(); + + + + public int glutVideoResizeGet(int param); + public void glutSetupVideoResizing(); + public void glutStopVideoResizing(); + public void glutVideoResize(int x, int y, int width, int height); + public void glutVideoPan(int x, int y, int width, int height); + + + public void glutReportErrors(); +} + + + + diff --git a/gl4java/utils/glut/GLUTFuncLightImpl.java b/gl4java/utils/glut/GLUTFuncLightImpl.java new file mode 100644 index 0000000..0d75311 --- /dev/null +++ b/gl4java/utils/glut/GLUTFuncLightImpl.java @@ -0,0 +1,847 @@ +/* Copyright (c) Mark J. Kilgard, 1994. */ + +/** +(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 adverti(float)Math.sing 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.227f.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227f-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. +*/ + + +package gl4java.utils.glut; + +import gl4java.GLFunc; +import gl4java.GLEnum; +import gl4java.GLUFunc; +import gl4java.GLUEnum; + +import java.lang.*; + +public class GLUTFuncLightImpl +implements GLUTFunc, GLEnum, GLUEnum +{ + public GLUTFuncLightImpl(GLFunc gl, GLUFunc glu) + { + init(gl, glu); + } + + public void init(GLFunc gl, GLUFunc glu) + { + this.gl = gl; + this.glu = glu; + initQuadObj(); + dodec = new float[20][3]; + initDodecahedron(); + initTeapot(); + } + + public String glutGetFontDescription(int font) + { + return "GLUTFuncLightImpl: no font support avaiable !"; + } + + public void glutBitmapString(int font, String s) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + } + + public int glutBitmapWidth(int font, int character) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public void glutStrokeString(int font, String s) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + } + + + public int glutStrokeWidth(int font, int character) + + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public int glutBitmapLength(int font, String string) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public int glutStrokeLength(int font, String string) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public final void glutWireSphere + (double radius, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_LINE); + glu.gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + glu.gluSphere(quadObj, radius, slices, stacks); + } + + public final void glutSolidSphere + (double radius, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_FILL); + glu.gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + glu.gluSphere(quadObj, radius, slices, stacks); + } + + public final void glutWireCone + (double base, double height, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_LINE); + glu.gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks); + } + + public final void glutSolidCone + (double base, double height, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_FILL); + glu.gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks); + } + + public final void glutWireCube(double size) + { + drawBox(size, GL_LINE_LOOP); + } + + public final void glutSolidCube(double size) + { + drawBox(size, GL_QUADS); + } + + public final void glutWireTorus + (double innerRadius, double outerRadius, + int sides, int rings) + { + gl.glPushAttrib(GL_POLYGON_BIT); + gl.glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + doughnut((float)innerRadius, (float)outerRadius, sides, rings); + gl.glPopAttrib(); + } + + public final void glutSolidTorus + (double innerRadius, double outerRadius, + int sides, int rings) + { + doughnut((float)innerRadius, (float)outerRadius, sides, rings); + } + + public final void glutWireDodecahedron() + { + dodecahedron(GL_LINE_LOOP); + } + + public final void glutSolidDodecahedron() + { + dodecahedron(GL_TRIANGLE_FAN); + } + + public final void glutWireOctahedron() + { + octahedron(GL_LINE_LOOP); + } + + public final void glutSolidOctahedron() + { + octahedron(GL_TRIANGLES); + } + + public final void glutWireIcosahedron() + { + icosahedron(GL_LINE_LOOP); + } + + public final void glutSolidIcosahedron() + { + icosahedron(GL_TRIANGLES); + } + + public final void glutWireTetrahedron() + { + tetrahedron(GL_LINE_LOOP); + } + + public final void glutSolidTetrahedron() + { + tetrahedron(GL_TRIANGLES); + } + + public final void glutWireTeapot(double size) + { + teapot(10, size, GL_LINE); + } + + public final void glutSolidTeapot(double size) + { + teapot(14, size, GL_FILL); + } + + public final int glutVideoResizeGet(int param) + { System.out.println("Not implemented in GLUT light implementation !"); + return 0; + } + + public final void glutSetupVideoResizing() + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutStopVideoResizing() + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutVideoResize(int x, int y, int width, int height) + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutVideoPan(int x, int y, int width, int height) + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutReportErrors() + { + int error; + + while ((error = gl.glGetError()) != GL_NO_ERROR) + __glutWarning("GL error: "+glu.gluErrorString(error)); + } + + /***************************************************************/ + + protected GLFunc gl = null; + protected GLUFunc glu = null; + + protected int quadObj=0; + + protected final void initQuadObj() + { + if(0==quadObj) quadObj = glu.gluNewQuadric(); + if (0==quadObj) + __glutFatalError("out of memory."); + } + + protected static final float n[/*6*/][/*3*/] = + { + {-1.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {1.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 0.0f, 1.0f}, + {0.0f, 0.0f, -1.0f} + }; + protected static final int faces[/*6*/][/*4*/] = + { + {0, 1, 2, 3}, + {3, 2, 6, 7}, + {7, 6, 5, 4}, + {4, 5, 1, 0}, + {5, 6, 2, 1}, + {7, 4, 0, 3} + }; + + protected final void drawBox(double size, int type) + { + float v[][] = new float[8][3]; + float sz = (float)size; + int i; + + v[0][0] = v[1][0] = v[2][0] = v[3][0] = -sz / 2.0f; + v[4][0] = v[5][0] = v[6][0] = v[7][0] = sz / 2.0f; + v[0][1] = v[1][1] = v[4][1] = v[5][1] = -sz / 2.0f; + v[2][1] = v[3][1] = v[6][1] = v[7][1] = sz / 2.0f; + v[0][2] = v[3][2] = v[4][2] = v[7][2] = -sz / 2.0f; + v[1][2] = v[2][2] = v[5][2] = v[6][2] = sz / 2.0f; + + for (i = 5; i >= 0; i--) { + gl.glBegin(type); + gl.glNormal3fv( n[i] ); + gl.glVertex3fv( v[ faces[i][0] ] ); + gl.glVertex3fv( v[ faces[i][1] ] ); + gl.glVertex3fv( v[ faces[i][2] ] ); + gl.glVertex3fv( v[ faces[i][3] ] ); + gl.glEnd(); + } + } + + protected static final float M_PI = 3.14159265358979323846f ; + + protected final void doughnut(float r, float R, int nsides, int rings) + { + int i, j; + float theta, phi, theta1; + float cosTheta, sinTheta; + float cosTheta1, sinTheta1; + float ringDelta, sideDelta; + + ringDelta = 2.0f * M_PI / rings; + sideDelta = 2.0f * M_PI / nsides; + + theta = 0.0f; + cosTheta = 1.0f; + sinTheta = 0.0f; + for (i = rings - 1; i >= 0; i--) + { + theta1 = theta + ringDelta; + cosTheta1 = (float)Math.cos(theta1); + sinTheta1 = (float)Math.sin(theta1); + gl.glBegin(GL_QUAD_STRIP); + phi = 0.0f; + for (j = nsides; j >= 0; j--) { + float cosPhi, sinPhi, dist; + + phi += sideDelta; + cosPhi = (float)Math.cos(phi); + sinPhi = (float)Math.sin(phi); + dist = R + r * cosPhi; + + gl.glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi); + gl.glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi); + gl.glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi); + gl.glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi); + } + gl.glEnd(); + theta = theta1; + cosTheta = cosTheta1; + sinTheta = sinTheta1; + } + } + + protected static float dodec[/*20*/][/*3*/] = null; + + protected static int dodec_inited = 0; + + protected static final void initDodecahedron() + { + if (dodec_inited != 0) { + return; + } + + dodec_inited = 1; + dodec = new float [20][3]; + + float alpha, beta; + + alpha = (float)Math.sqrt(2.0f / (3.0f + (float)Math.sqrt(5.0f))); + beta = 1.0f + (float)Math.sqrt(6.0f / (3.0f + (float)Math.sqrt(5.0f)) + - + 2.0f + 2.0f * (float)Math.sqrt(2.0f / (3.0f + (float)Math.sqrt(5.0f)))); + /* *INDENT-OFF* */ + dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta; + dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta; + dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1; + dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1; + dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1; + dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1; + dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1; + dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1; + dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1; + dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1; + dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0; + dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0; + dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0; + dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0; + dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta; + dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta; + dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha; + dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha; + dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha; + dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha; + /* *INDENT-ON* */ + + } + + protected static final void DIFF3f(float[] _a, float[] _b, float[] _c) + { + (_c)[0] = (_a)[0] - (_b)[0]; + (_c)[1] = (_a)[1] - (_b)[1]; + (_c)[2] = (_a)[2] - (_b)[2]; + } + + protected static final void crossprod + (float v1[/*3*/], float v2[/*3*/], float prod[/*3*/]) + { + float p[] = new float[3]; /* in case prod == v1 or v2 */ + + p[0] = v1[1] * v2[2] - v2[1] * v1[2]; + p[1] = v1[2] * v2[0] - v2[2] * v1[0]; + p[2] = v1[0] * v2[1] - v2[0] * v1[1]; + prod[0] = p[0]; + prod[1] = p[1]; + prod[2] = p[2]; + } + + protected static final void normalize(float v[/*3*/]) + { + float d; + + d = (float)Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); + if (d == 0.0f) { + __glutWarning("normalize: zero length vector"); + v[0] = d = 1.0f; + } + d = 1 / d; + v[0] *= d; + v[1] *= d; + v[2] *= d; + } + + protected final void + pentagon(int a, int b, int c, int d, int e, int shadeType) + { + float n0[] = new float[3]; + float d1[] = new float[3]; + float d2[] = new float[3]; + + DIFF3f(dodec[a], dodec[b], d1); + DIFF3f(dodec[b], dodec[c], d2); + crossprod(d1, d2, n0); + normalize(n0); + + gl.glBegin(shadeType); + gl.glNormal3fv(n0); + gl.glVertex3fv(dodec[a]); + gl.glVertex3fv(dodec[b]); + gl.glVertex3fv(dodec[c]); + gl.glVertex3fv(dodec[d]); + gl.glVertex3fv(dodec[e]); + gl.glEnd(); + } + + protected final void dodecahedron(int type) + { + + pentagon(0, 1, 9, 16, 5, type); + pentagon(1, 0, 3, 18, 7, type); + pentagon(1, 7, 11, 10, 9, type); + pentagon(11, 7, 18, 19, 6, type); + pentagon(8, 17, 16, 9, 10, type); + pentagon(2, 14, 15, 6, 19, type); + pentagon(2, 13, 12, 4, 14, type); + pentagon(2, 19, 18, 3, 13, type); + pentagon(3, 0, 5, 12, 13, type); + pentagon(6, 15, 8, 10, 11, type); + pentagon(4, 17, 8, 15, 14, type); + pentagon(4, 12, 5, 16, 17, type); + } + + protected final void + recorditem(float[] n1, float[] n2, float[] n3, int shadeType) + { + float q0[] = new float[3]; + float q1[] = new float[3]; + + DIFF3f(n1, n2, q0); + DIFF3f(n2, n3, q1); + crossprod(q0, q1, q1); + normalize(q1); + + gl.glBegin(shadeType); + gl.glNormal3fv(q1); + gl.glVertex3fv(n1); + gl.glVertex3fv(n2); + gl.glVertex3fv(n3); + gl.glEnd(); + } + + protected final void + subdivide(float[] v0, float[] v1, float[] v2, int shadeType) + { + int depth; + float w0[] = new float[3]; + float w1[] = new float[3]; + float w2[] = new float[3]; + float l; + int i, j, k, n; + + depth = 1; + for (i = 0; i < depth; i++) { + for (j = 0; i + j < depth; j++) { + k = depth - i - j; + for (n = 0; n < 3; n++) { + w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth; + w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n]) + / depth; + w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n]) + / depth; + } + l = (float)Math.sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]); + w0[0] /= l; + w0[1] /= l; + w0[2] /= l; + l = (float)Math.sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]); + w1[0] /= l; + w1[1] /= l; + w1[2] /= l; + l = (float)Math.sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]); + w2[0] /= l; + w2[1] /= l; + w2[2] /= l; + recorditem(w1, w0, w2, shadeType); + } + } + } + + protected final void + drawtriangle(int i, float data[][/*3*/], int ndx[][/*3*/], + int shadeType) + { + float x0[], x1[], x2[]; + + x0 = data[ndx[i][0]]; + x1 = data[ndx[i][1]]; + x2 = data[ndx[i][2]]; + subdivide(x0, x1, x2, shadeType); + } + + /* octahedron data: The octahedron produced is centered at the + origin and has radius 1.0f */ + protected static final float odata[/*6*/][/*3*/] = + { + {1.0f, 0.0f, 0.0f}, + {-1.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 0.0f, 1.0f}, + {0.0f, 0.0f, -1.0f} + }; + + protected static final int ondex[/*8*/][/*3*/] = + { + {0, 4, 2}, + {1, 2, 4}, + {0, 3, 4}, + {1, 4, 3}, + {0, 2, 5}, + {1, 5, 2}, + {0, 5, 3}, + {1, 3, 5} + }; + + protected final void + octahedron(int shadeType) + { + int i; + + for (i = 7; i >= 0; i--) { + drawtriangle(i, odata, ondex, shadeType); + } + } + + protected static final float X = .525731112119133606f; + protected static final float Z = .850650808352039932f; + + protected static final float idata[/*12*/][/*3*/] = + { + {-X, 0, Z}, + {X, 0, Z}, + {-X, 0, -Z}, + {X, 0, -Z}, + {0, Z, X}, + {0, Z, -X}, + {0, -Z, X}, + {0, -Z, -X}, + {Z, X, 0}, + {-Z, X, 0}, + {Z, -X, 0}, + {-Z, -X, 0} + }; + + protected static final int index[/*20*/][/*3*/] = + { + {0, 4, 1}, + {0, 9, 4}, + {9, 5, 4}, + {4, 5, 8}, + {4, 8, 1}, + {8, 10, 1}, + {8, 3, 10}, + {5, 3, 8}, + {5, 2, 3}, + {2, 7, 3}, + {7, 10, 3}, + {7, 6, 10}, + {7, 11, 6}, + {11, 0, 6}, + {0, 1, 6}, + {6, 1, 10}, + {9, 0, 11}, + {9, 11, 2}, + {9, 2, 5}, + {7, 2, 11}, + }; + + protected final void icosahedron(int shadeType) + { + int i; + + for (i = 19; i >= 0; i--) { + drawtriangle(i, idata, index, shadeType); + } + } + + protected static final float T = 1.73205080756887729f; + + protected static final float tdata[/*4*/][/*3*/] = + { + {T, T, T}, + {T, -T, -T}, + {-T, T, -T}, + {-T, -T, T} + }; + + protected static final int tndex[/*4*/][/*3*/] = + { + {0, 1, 3}, + {2, 1, 0}, + {3, 2, 0}, + {1, 2, 3} + }; + + protected final void tetrahedron(int shadeType) + { + int i; + + for (i = 3; i >= 0; i--) + drawtriangle(i, tdata, tndex, shadeType); + } + + /** + * The Teapot + */ + + /* Rim, body, lid, and bottom data must be reflected in x and + y; handle and spout data across the y axis only. */ + private static final int patchdata[][] = + { + /* rim */ + {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15}, + /* body */ + {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27}, + {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40}, + /* lid */ + {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, + 101, 0, 1, 2, 3,}, + {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117}, + /* bottom */ + {118, 118, 118, 118, 124, 122, 119, 121, 123, 126, + 125, 120, 40, 39, 38, 37}, + /* handle */ + {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56}, + {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 28, 65, 66, 67}, + /* spout */ + {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83}, + {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95} + }; + private static final float cpdata[][] = + { + {0.2f, 0.0f, 2.7f}, {0.2f, -0.112f, 2.7f}, {0.112f, -0.2f, 2.7f}, {0.0f, + -0.2f, 2.7f}, {1.3375f, 0.0f, 2.53125f}, {1.3375f, -0.749f, 2.53125f}, + {0.749f, -1.3375f, 2.53125f}, {0.0f, -1.3375f, 2.53125f}, {1.4375f, + 0.0f, 2.53125f}, {1.4375f, -0.805f, 2.53125f}, {0.805f, -1.4375f, + 2.53125f}, {0.0f, -1.4375f, 2.53125f}, {1.5f, 0.0f, 2.4f}, {1.5f, -0.84f, + 2.4f}, {0.84f, -1.5f, 2.4f}, {0.0f, -1.5f, 2.4f}, {1.75f, 0.0f, 1.875f}, + {1.75f, -0.98f, 1.875f}, {0.98f, -1.75f, 1.875f}, {0.0f, -1.75f, + 1.875f}, {2f, 0.0f, 1.35f}, {2f, -1.12f, 1.35f}, {1.12f, -2f, 1.35f}, + {0.0f, -2f, 1.35f}, {2f, 0.0f, 0.9f}, {2f, -1.12f, 0.9f}, {1.12f, -2f, + 0.9f}, {0.0f, -2f, 0.9f}, {-2f, 0.0f, 0.9f}, {2f, 0.0f, 0.45f}, {2f, -1.12f, + 0.45f}, {1.12f, -2f, 0.45f}, {0.0f, -2f, 0.45f}, {1.5f, 0.0f, 0.225f}, + {1.5f, -0.84f, 0.225f}, {0.84f, -1.5f, 0.225f}, {0.0f, -1.5f, 0.225f}, + {1.5f, 0.0f, 0.15f}, {1.5f, -0.84f, 0.15f}, {0.84f, -1.5f, 0.15f}, {0.0f, + -1.5f, 0.15f}, {-1.6f, 0.0f, 2.025f}, {-1.6f, -0.3f, 2.025f}, {-1.5f, + -0.3f, 2.25f}, {-1.5f, 0.0f, 2.25f}, {-2.3f, 0.0f, 2.025f}, {-2.3f, -0.3f, + 2.025f}, {-2.5f, -0.3f, 2.25f}, {-2.5f, 0.0f, 2.25f}, {-2.7f, 0.0f, + 2.025f}, {-2.7f, -0.3f, 2.025f}, {-3f, -0.3f, 2.25f}, {-3f, 0.0f, + 2.25f}, {-2.7f, 0.0f, 1.8f}, {-2.7f, -0.3f, 1.8f}, {-3f, -0.3f, 1.8f}, + {-3f, 0.0f, 1.8f}, {-2.7f, 0.0f, 1.575f}, {-2.7f, -0.3f, 1.575f}, {-3f, + -0.3f, 1.35f}, {-3f, 0.0f, 1.35f}, {-2.5f, 0.0f, 1.125f}, {-2.5f, -0.3f, + 1.125f}, {-2.65f, -0.3f, 0.9375f}, {-2.65f, 0.0f, 0.9375f}, {-2f, + -0.3f, 0.9f}, {-1.9f, -0.3f, 0.6f}, {-1.9f, 0.0f, 0.6f}, {1.7f, 0.0f, + 1.425f}, {1.7f, -0.66f, 1.425f}, {1.7f, -0.66f, 0.6f}, {1.7f, 0.0f, + 0.6f}, {2.6f, 0.0f, 1.425f}, {2.6f, -0.66f, 1.425f}, {3.1f, -0.66f, + 0.825f}, {3.1f, 0.0f, 0.825f}, {2.3f, 0.0f, 2.1f}, {2.3f, -0.25f, 2.1f}, + {2.4f, -0.25f, 2.025f}, {2.4f, 0.0f, 2.025f}, {2.7f, 0.0f, 2.4f}, {2.7f, + -0.25f, 2.4f}, {3.3f, -0.25f, 2.4f}, {3.3f, 0.0f, 2.4f}, {2.8f, 0.0f, + 2.475f}, {2.8f, -0.25f, 2.475f}, {3.525f, -0.25f, 2.49375f}, + {3.525f, 0.0f, 2.49375f}, {2.9f, 0.0f, 2.475f}, {2.9f, -0.15f, 2.475f}, + {3.45f, -0.15f, 2.5125f}, {3.45f, 0.0f, 2.5125f}, {2.8f, 0.0f, 2.4f}, + {2.8f, -0.15f, 2.4f}, {3.2f, -0.15f, 2.4f}, {3.2f, 0.0f, 2.4f}, {0.0f, 0.0f, + 3.15f}, {0.8f, 0.0f, 3.15f}, {0.8f, -0.45f, 3.15f}, {0.45f, -0.8f, + 3.15f}, {0.0f, -0.8f, 3.15f}, {0.0f, 0.0f, 2.85f}, {1.4f, 0.0f, 2.4f}, {1.4f, + -0.784f, 2.4f}, {0.784f, -1.4f, 2.4f}, {0.0f, -1.4f, 2.4f}, {0.4f, 0.0f, + 2.55f}, {0.4f, -0.224f, 2.55f}, {0.224f, -0.4f, 2.55f}, {0.0f, -0.4f, + 2.55f}, {1.3f, 0.0f, 2.55f}, {1.3f, -0.728f, 2.55f}, {0.728f, -1.3f, + 2.55f}, {0.0f, -1.3f, 2.55f}, {1.3f, 0.0f, 2.4f}, {1.3f, -0.728f, 2.4f}, + {0.728f, -1.3f, 2.4f}, {0.0f, -1.3f, 2.4f}, {0.0f, 0.0f, 0.0f}, {1.425f, + -0.798f, 0.0f}, {1.5f, 0.0f, 0.075f}, {1.425f, 0.0f, 0.0f}, {0.798f, -1.425f, + 0.0f}, {0.0f, -1.5f, 0.075f}, {0.0f, -1.425f, 0.0f}, {1.5f, -0.84f, 0.075f}, + {0.84f, -1.5f, 0.075f} + }; + private static final float tex[] = + { + 0.0f, 0.0f, + 1.0f, 0.0f, + 0.0f, 1.0f, + 1.0f, 1.0f + }; + + boolean _tp_init = false; + float _tp_p[] = null; + float _tp_q[] = null; + float _tp_r[] = null; + float _tp_s[] = null; + + private final void initTeapot() + { + if(_tp_init==true) + return; + + _tp_p = new float[4*4*3]; + _tp_q = new float[4*4*3]; + _tp_r = new float[4*4*3]; + _tp_s = new float[4*4*3]; + } + + // Imported from glut. + private final void teapot(int grid, double scale, int type) + { + float sc = (float)(0.5*scale); + + gl.glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT); + gl.glEnable(GL_AUTO_NORMAL); + gl.glEnable(GL_NORMALIZE); + gl.glEnable(GL_MAP2_VERTEX_3); + gl.glEnable(GL_MAP2_TEXTURE_COORD_2); + gl.glPushMatrix(); + gl.glRotatef(270.0f, 1.0f, 0.0f, 0.0f); + gl.glScalef(sc, sc, sc); + gl.glTranslatef(0.0f, 0.0f, -1.5f); + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 4; j++) + { + for (int k = 0; k < 4; k++) + { + for (int l = 0; l < 3; l++) + { + _tp_p[(j*12)+(k*3)+l] = cpdata[patchdata[i][j * 4 + k]][l]; + _tp_q[(j*12)+(k*3)+l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 1) + _tp_q[(j*12)+(k*3)+l] *= -1.0f; + if (i < 6) + { + _tp_r[(j*12)+(k*3)+l] = + cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 0) + _tp_r[(j*12)+(k*3)+l] *= -1.0f; + _tp_s[(j*12)+(k*3)+l] = + cpdata[patchdata[i][j * 4 + k]][l]; + if (l == 0) + _tp_s[(j*12)+(k*3)+l] *= -1.0f; + if (l == 1) + _tp_s[(j*12)+(k*3)+l] *= -1.0f; + } + } + } + } + gl.glMap2f + (GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, tex); + gl.glMap2f + (GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_p); + gl.glMapGrid2f(grid, 0.0f, 1.0f, grid, 0.0f, 1.0f); + gl.glEvalMesh2(type, 0, grid, 0, grid); + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_q); + gl.glEvalMesh2(type, 0, grid, 0, grid); + if (i < 6) + { + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_r); + gl.glEvalMesh2(type, 0, grid, 0, grid); + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_s); + gl.glEvalMesh2(type, 0, grid, 0, grid); + } + } + gl.glPopMatrix(); + gl.glPopAttrib(); + } + + protected static final void __glutWarning(String str) + { + System.out.println("GLUT: Warning in (unamed): "+str+"\n"); + } + + protected static final void __glutFatalError(String str) + { + System.out.println("GLUT: Fatal Error in (unamed): "+str+"\n"); + Exception ex = new Exception(); + ex.printStackTrace(); + System.exit(1); + } + +} + + + + diff --git a/gl4java/utils/glut/fonts/BitmapCharRec.java b/gl4java/utils/glut/fonts/BitmapCharRec.java new file mode 100644 index 0000000..b23cd23 --- /dev/null +++ b/gl4java/utils/glut/fonts/BitmapCharRec.java @@ -0,0 +1,28 @@ +// Bitmap Character Record +// by Pontus Lidman +// based on GLUT 3.7 glutbitmap.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class BitmapCharRec { + public int width=0; + public int height=0; + public float xorig=0; + public float yorig=0; + public float advance=0; + public byte[] bitmap=null; + + public BitmapCharRec(int w,int h, float xo, float yo, float adv, byte[] bm) { + width=w; + height=h; + xorig=xo; + yorig=yo; + advance=adv; + bitmap=bm; + } +} diff --git a/gl4java/utils/glut/fonts/BitmapFontRec.java b/gl4java/utils/glut/fonts/BitmapFontRec.java new file mode 100644 index 0000000..f4db5d1 --- /dev/null +++ b/gl4java/utils/glut/fonts/BitmapFontRec.java @@ -0,0 +1,24 @@ +// Bitmap Font Record +// by Pontus Lidman +// based on GLUT 3.7 glutbitmap.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class BitmapFontRec { + public String name=null; + public int num_chars=0; + public int first=0; + public BitmapCharRec[] ch=null; + + public BitmapFontRec(String n,int num,int f,BitmapCharRec[] recs) { + name=n; + num_chars=num; + first=f; + ch=recs; + } +} diff --git a/gl4java/utils/glut/fonts/CoordRec.java b/gl4java/utils/glut/fonts/CoordRec.java new file mode 100644 index 0000000..cadd5c0 --- /dev/null +++ b/gl4java/utils/glut/fonts/CoordRec.java @@ -0,0 +1,19 @@ +// Coordinate Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class CoordRec { + public float x; + public float y; + public CoordRec(float x, float y) { + this.x=x; + this.y=y; + } +} diff --git a/gl4java/utils/glut/fonts/GLUTBitmapFont.java b/gl4java/utils/glut/fonts/GLUTBitmapFont.java new file mode 100644 index 0000000..37922be --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTBitmapFont.java @@ -0,0 +1,12 @@ +// Intended to be an interface for GLUT font structures +// by Pontus Lidman +// Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public interface GLUTBitmapFont { +} diff --git a/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java b/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java new file mode 100644 index 0000000..ce9ca5e --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java @@ -0,0 +1,300 @@ +/* Copyright (c) Mark J. Kilgard, 1994. */ + +/** +(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 adverti(float)Math.sing 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.227f.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227f-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. +*/ + + +package gl4java.utils.glut.fonts; + +import gl4java.utils.glut.*; +import gl4java.utils.glut.fonts.data.*; + +import gl4java.GLFunc; +import gl4java.GLEnum; +import gl4java.GLUFunc; +import gl4java.GLUEnum; + +import java.lang.*; + +public class GLUTFuncLightImplWithFonts extends GLUTFuncLightImpl +implements GLEnum, GLUEnum +{ + public GLUTFuncLightImplWithFonts(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + public final String glutGetFontDescription(int font) + { + switch(font) { + case GLUT_STROKE_ROMAN: + return "stroke roman"; + case GLUT_STROKE_MONO_ROMAN: + return "stroke roman mono"; + case GLUT_BITMAP_9_BY_15: + return "bitmap 9x15"; + case GLUT_BITMAP_8_BY_13: + return "bitmap 8x13"; + case GLUT_BITMAP_TIMES_ROMAN_10: + return "bitmap roman 10"; + case GLUT_BITMAP_TIMES_ROMAN_24: + return "bitmap roman 24"; + case GLUT_BITMAP_HELVETICA_10: + return "bitmap helvetica 10"; + case GLUT_BITMAP_HELVETICA_12: + return "bitmap helvetica 12"; + case GLUT_BITMAP_HELVETICA_18: + return "bitmap helvetica 18"; + } + return "unknown font enumeration: "+font; + } + + private final BitmapFontRec getFontInfo(int font) { + try { + switch(font) { + case GLUT_BITMAP_HELVETICA_10: + return glutBitmapHelvetica10.getBitmapFontRec(); + case GLUT_BITMAP_HELVETICA_12: + return glutBitmapHelvetica12.getBitmapFontRec(); + case GLUT_BITMAP_HELVETICA_18: + return glutBitmapHelvetica12.getBitmapFontRec(); + case GLUT_BITMAP_8_BY_13: + return glutBitmap8By13.getBitmapFontRec(); + case GLUT_BITMAP_9_BY_15: + return glutBitmap9By15.getBitmapFontRec(); + case GLUT_BITMAP_TIMES_ROMAN_10: + return glutBitmapTimesRoman10.getBitmapFontRec(); + case GLUT_BITMAP_TIMES_ROMAN_24: + return glutBitmapTimesRoman24.getBitmapFontRec(); + } + } catch (Exception ex) { + System.out.println("Font not supported: "+ glutGetFontDescription(font)); + } + return null; + } + + private final StrokeFontRec getStrokeFontInfo(int font) { + try { + switch(font) { + case GLUT_STROKE_MONO_ROMAN: + return glutStrokeMonoRoman.getStrokeFontRec(); + case GLUT_STROKE_ROMAN: + return glutStrokeRoman.getStrokeFontRec(); + } + } catch (Exception ex) { + System.out.println("Font not supported: "+ glutGetFontDescription(font)); + } + return null; + } + + public final void glutBitmapString(int font, String s) + { + BitmapCharRec ch; + BitmapFontRec fontinfo; + + int[] swapbytes=new int[1]; + int[] lsbfirst=new int[1]; + int[] rowlength=new int[1]; + int[] skiprows=new int[1]; + int[] skippixels=new int[1]; + int[] alignment=new int[1]; + + fontinfo=getFontInfo(font); + + byte[] bytes=s.getBytes(); + int character; + + /* Save current modes. */ + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL_UNPACK_ALIGNMENT, alignment); + /* Little endian machines (DEC Alpha for example) could + benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE + instead of GL_FALSE, but this would require changing the + generated bitmaps too. */ + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); // GL_FALSE + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 0); // GL_FALSE + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + for (int i=0; i= fontinfo.first + fontinfo.num_chars) + continue; + ch = fontinfo.ch[character - fontinfo.first]; + if (ch == null) continue; + + gl.glBitmap(ch.width, ch.height, ch.xorig, ch.yorig, + ch.advance, 0, ch.bitmap); + } + /* Restore saved modes. */ + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, alignment[0]); + } + + public final int glutBitmapWidth(int font, int character) + { + + BitmapFontRec fontinfo; + BitmapCharRec ch; + + fontinfo = getFontInfo(font); + + if ((character < fontinfo.first) || (character >= fontinfo.first + fontinfo.num_chars)) + return 0; + ch = fontinfo.ch[character - fontinfo.first]; + if (ch != null) + return (int) ch.advance; + else + return 0; + } + + public final void glutStrokeString(int font, String s) + { + StrokeCharRec ch; + StrokeRec stroke; + CoordRec coord; + StrokeFontRec fontinfo; + int i, j, k, c; + byte[] bytes=s.getBytes(); + + fontinfo = getStrokeFontInfo(font); + + for (i=0; i= fontinfo.num_chars) + continue; + ch = fontinfo.ch[c]; + if (ch == null) continue; + for (j=0; j< ch.num_strokes; j++) { + stroke=ch.stroke[j]; + gl.glBegin(GL_LINE_STRIP); + for (k = 0; k< stroke.num_coords; k++) { + coord = stroke.coord[k]; + gl.glVertex2f(coord.x, coord.y); + } + gl.glEnd(); + } + gl.glTranslatef(ch.right, (float) 0.0, (float) 0.0); + } + } + + + public final int glutStrokeWidth(int font, int character) + + { + + StrokeFontRec fontinfo; + StrokeCharRec ch; + + fontinfo = getStrokeFontInfo(font); + + if (character < 0 || character >= fontinfo.num_chars) + return 0; + ch = fontinfo.ch[character]; + if (ch != null) + return (int) ch.right; + else + return 0; + } + + public final int glutBitmapLength(int font, String string) + { + int c; + int length; + int i; + BitmapFontRec fontinfo; + BitmapCharRec ch; + byte[] bytestring=string.getBytes(); + + fontinfo = getFontInfo(font); + + length = 0; + for (i=0; i= fontinfo.first) && (c < fontinfo.first + fontinfo.num_chars)) { + ch = fontinfo.ch[c - fontinfo.first]; + if (ch != null) + length += ch.advance; + } + } + return length; + } + + public final int glutStrokeLength(int font, String string) + { + int c, length; + StrokeFontRec fontinfo; + StrokeCharRec ch; + byte[] bytestring=string.getBytes(); + + fontinfo=getStrokeFontInfo(font); + + length = 0; + for (int i=0; i= 0 && c < fontinfo.num_chars) { + ch = fontinfo.ch[c]; + if (ch != null) + length += ch.right; + } + } + return length; + } +} + + + + diff --git a/gl4java/utils/glut/fonts/GLUTStrokeFont.java b/gl4java/utils/glut/fonts/GLUTStrokeFont.java new file mode 100644 index 0000000..a9c9691 --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTStrokeFont.java @@ -0,0 +1,5 @@ +package gl4java.utils.glut.fonts; + +public interface GLUTStrokeFont { +} + diff --git a/gl4java/utils/glut/fonts/LICENSE.txt b/gl4java/utils/glut/fonts/LICENSE.txt new file mode 100644 index 0000000..6287344 --- /dev/null +++ b/gl4java/utils/glut/fonts/LICENSE.txt @@ -0,0 +1,28 @@ +GLUT Font Support for GL4Java ! + +Author: Pontus Lidman / MathCore (creator and original author) + and + Sven Goethel / Jausoft (changes for GL4Java packaging and little changes) +Copyright 2000: MathCore AB & LGPL (see below) + +This file/package is licensed under the terms of the LPGL (see below) +with the permission of Pontus Lidman / Mathcore - THANXS ! + +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. + +You can also check the GNU Library General Public License +in the internet at http://www.gnu.org/copyleft/lgpl.html ! + diff --git a/gl4java/utils/glut/fonts/Makefile b/gl4java/utils/glut/fonts/Makefile new file mode 100644 index 0000000..07fe919 --- /dev/null +++ b/gl4java/utils/glut/fonts/Makefile @@ -0,0 +1,110 @@ +# Makefile to generate java classes from X fonts +# (including compilation of capturexfont.c) +# by Pontus Lidman +# Copyright 2000 MathCore AB +# +# This file/package is licensed under the terms of the LPGL +# with the permission of Pontus Lidman / Mathcore ! +# + +all: cxf strokegen fonts + +cxf: capturexfont.c + gcc -g -Wall capturexfont.c -o cxf -L/usr/X11/lib -lX11 + +strokegen : strokegen.o strokelex.o + $(CC) -o $@ $(CFLAGS) strokegen.o strokelex.o + +glut_roman.c : Roman.stroke strokegen + ./strokegen -s glutStrokeRoman < Roman.stroke > $@ + +glut_mroman.c : MonoRoman.stroke strokegen + ./strokegen -s glutStrokeMonoRoman < MonoRoman.stroke > $@ + +strokegen.h strokegen.c : strokegen.y + $(YACC) -d strokegen.y + mv y.tab.c strokegen.c + mv y.tab.h strokegen.h + +strokelex.c : strokelex.l + $(LEX) strokelex.l + mv lex.yy.c strokelex.c + +fonts: data/glutBitmapHelvetica10.java \ + data/glutBitmapHelvetica12.java \ + data/glutBitmapHelvetica18.java \ + data/glutBitmapTimesRoman10.java \ + data/glutBitmapTimesRoman24.java \ + data/glutBitmap8By13.java \ + data/glutBitmap9By15.java \ + data/glutStrokeRoman.java \ + data/glutStrokeMonoRoman.java + +data/glutBitmapHelvetica12.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--12-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica12 \ + >data/glutBitmapHelvetica12.java + +data/glutBitmapHelvetica10.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--10-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica10 \ + >data/glutBitmapHelvetica10.java + +data/glutBitmapHelvetica18.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--18-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica18 \ + >data/glutBitmapHelvetica18.java + +data/glutBitmapTimesRoman10.java: cxf + ./cxf \ + '-adobe-times-medium-r-*--10-*-*-*-p-*-iso8859-1' \ + glutBitmapTimesRoman10 \ + >data/glutBitmapTimesRoman10.java + +data/glutBitmapTimesRoman24.java: cxf + ./cxf \ + '-adobe-times-medium-r-*--24-*-*-*-p-*-iso8859-1' \ + glutBitmapTimesRoman24 \ + >data/glutBitmapTimesRoman24.java + +data/glutBitmap8By13.java: cxf + ./cxf \ + 8x13 \ + glutBitmap8By13 \ + >data/glutBitmap8By13.java + +data/glutBitmap9By15.java: cxf + ./cxf \ + 9x15 \ + glutBitmap9By15 \ + >data/glutBitmap9By15.java + +data/glutStrokeMonoRoman.java: strokegen + ./strokegen -s glutStrokeMonoRoman data/glutStrokeMonoRoman.java + +data/glutStrokeRoman.java: strokegen + ./strokegen -s glutStrokeRoman data/glutStrokeRoman.java + +clean: + rm -f *.o cxf strokegen \ + glut_roman.c \ + glut_mroman.c \ + strokegen.h \ + strokegen.c \ + strokelex.c + +cleanall: clean + rm -f *.class \ + data/glutBitmapHelvetica10.java \ + data/glutBitmapHelvetica12.java \ + data/glutBitmapHelvetica18.java \ + data/glutBitmapTimesRoman10.java \ + data/glutBitmapTimesRoman24.java \ + data/glutBitmap8By13.java \ + data/glutBitmap9By15.java \ + data/glutStrokeRoman.java \ + data/glutStrokeMonoRoman.java + diff --git a/gl4java/utils/glut/fonts/MonoRoman.stroke b/gl4java/utils/glut/fonts/MonoRoman.stroke new file mode 100644 index 0000000..5bd84f7 --- /dev/null +++ b/gl4java/utils/glut/fonts/MonoRoman.stroke @@ -0,0 +1,503 @@ +## +# $XConsortium: Roman_M.src,v 5.2 91/07/21 16:42:40 rws Exp $ +## +## Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium. +## +## All Rights Reserved +## +## Permission to use, copy, modify, and distribute this software and its +## documentation for any purpose and without fee is hereby granted, +## provided that the above copyright notice appear in all copies and that +## both that copyright notice and this permission notice appear in +## supporting documentation, and that the names of Sun Microsystems, +## the X Consortium, and MIT not be used in advertising or publicity +## pertaining to distribution of the software without specific, written +## prior permission. +## +## SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +## INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +## EVENT SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +## CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +## USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +## OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +## PERFORMANCE OF THIS SOFTWARE. + +# Mono-spaced version of Roman Simplex font. + + FONTNAME Roman + TOP 119.0476 + BOTTOM -33.3333 + NUM_CH 128 + PROPERTIES 3 + + (CHARSET_REGISTRY ISO8859) + (CHARSET_ENCODING "1") + (SPACING M) + +INDEX 32 STROKE 0 CENTER 52.3810 RIGHT 104.7619 +INDEX 33 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 33.3333) + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 34 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (33.3334 100.0000) (33.3334 66.6667) + OPEN 2 (71.4286 100.0000) (71.4286 66.6667) +INDEX 35 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (54.7619 119.0476) (21.4286 -33.3333) + OPEN 2 (83.3334 119.0476) (50.0000 -33.3333) + OPEN 2 (21.4286 57.1429) (88.0952 57.1429) + OPEN 2 (16.6667 28.5714) (83.3334 28.5714) +INDEX 36 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (42.8571 119.0476) (42.8571 -19.0476) + OPEN 2 (61.9047 119.0476) (61.9047 -19.0476) + OPEN 20 (85.7143 85.7143) (76.1905 95.2381) (61.9047 100.0000) + (42.8571 100.0000) (28.5714 95.2381) (19.0476 85.7143) (19.0476 76.1905) + (23.8095 66.6667) (28.5714 61.9048) (38.0952 57.1429) (66.6666 47.6190) + (76.1905 42.8571) (80.9524 38.0952) (85.7143 28.5714) (85.7143 14.2857) + (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (19.0476 14.2857) +INDEX 37 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (95.2381 100.0000) (9.5238 0.0000) + OPEN 16 (33.3333 100.0000) (42.8571 90.4762) (42.8571 80.9524) + (38.0952 71.4286) (28.5714 66.6667) (19.0476 66.6667) (9.5238 76.1905) + (9.5238 85.7143) (14.2857 95.2381) (23.8095 100.0000) (33.3333 100.0000) + (42.8571 95.2381) (57.1428 90.4762) (71.4286 90.4762) (85.7143 95.2381) + (95.2381 100.0000) + OPEN 11 (76.1905 33.3333) (66.6667 28.5714) (61.9048 19.0476) + (61.9048 9.5238) (71.4286 0.0000) (80.9524 0.0000) (90.4762 4.7619) + (95.2381 14.2857) (95.2381 23.8095) (85.7143 33.3333) (76.1905 33.3333) +INDEX 38 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 34 (100.0000 57.1429) (100.0000 61.9048) (95.2381 66.6667) + (90.4762 66.6667) (85.7143 61.9048) (80.9524 52.3810) (71.4286 28.5714) + (61.9048 14.2857) (52.3809 4.7619) (42.8571 0.0000) (23.8095 0.0000) + (14.2857 4.7619) (9.5238 9.5238) (4.7619 19.0476) (4.7619 28.5714) + (9.5238 38.0952) (14.2857 42.8571) (47.6190 61.9048) (52.3809 66.6667) + (57.1429 76.1905) (57.1429 85.7143) (52.3809 95.2381) (42.8571 100.0000) + (33.3333 95.2381) (28.5714 85.7143) (28.5714 76.1905) (33.3333 61.9048) + (42.8571 47.6190) (66.6667 14.2857) (76.1905 4.7619) (85.7143 0.0000) + (95.2381 0.0000) (100.0000 4.7619) (100.0000 9.5238) +INDEX 39 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 66.6667) +INDEX 40 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (69.0476 119.0476) (59.5238 109.5238) (50.0000 95.2381) + (40.4762 76.1905) (35.7143 52.3810) (35.7143 33.3333) (40.4762 9.5238) + (50.0000 -9.5238) (59.5238 -23.8095) (69.0476 -33.3333) +INDEX 41 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (35.7143 119.0476) (45.2381 109.5238) (54.7619 95.2381) + (64.2857 76.1905) (69.0476 52.3810) (69.0476 33.3333) (64.2857 9.5238) + (54.7619 -9.5238) (45.2381 -23.8095) (35.7143 -33.3333) +INDEX 42 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 71.4286) (52.3810 14.2857) + OPEN 2 (28.5715 57.1429) (76.1905 28.5714) + OPEN 2 (76.1905 57.1429) (28.5715 28.5714) +INDEX 43 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 85.7143) (52.3809 0.0000) + OPEN 2 (9.5238 42.8571) (95.2381 42.8571) +INDEX 44 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 8 (57.1429 4.7619) (52.3810 0.0000) (47.6191 4.7619) + (52.3810 9.5238) (57.1429 4.7619) (57.1429 -4.7619) (52.3810 -14.2857) + (47.6191 -19.0476) +INDEX 45 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (9.5238 42.8571) (95.2381 42.8571) +INDEX 46 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 47 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 -14.2857) (85.7143 100.0000) +INDEX 48 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (47.6190 100.0000) (33.3333 95.2381) (23.8095 80.9524) + (19.0476 57.1429) (19.0476 42.8571) (23.8095 19.0476) (33.3333 4.7619) + (47.6190 0.0000) (57.1428 0.0000) (71.4286 4.7619) (80.9524 19.0476) + (85.7143 42.8571) (85.7143 57.1429) (80.9524 80.9524) (71.4286 95.2381) + (57.1428 100.0000) (47.6190 100.0000) +INDEX 49 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 4 (40.4762 80.9524) (50.0000 85.7143) (64.2857 100.0000) + (64.2857 0.0000) +INDEX 50 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (23.8095 76.1905) (23.8095 80.9524) (28.5714 90.4762) + (33.3333 95.2381) (42.8571 100.0000) (61.9047 100.0000) (71.4286 95.2381) + (76.1905 90.4762) (80.9524 80.9524) (80.9524 71.4286) (76.1905 61.9048) + (66.6666 47.6190) (19.0476 0.0000) (85.7143 0.0000) +INDEX 51 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 15 (28.5714 100.0000) (80.9524 100.0000) (52.3809 61.9048) + (66.6666 61.9048) (76.1905 57.1429) (80.9524 52.3810) (85.7143 38.0952) + (85.7143 28.5714) (80.9524 14.2857) (71.4286 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (28.5714 4.7619) (23.8095 9.5238) (19.0476 19.0476) +INDEX 52 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (64.2857 100.0000) (16.6667 33.3333) (88.0952 33.3333) + OPEN 2 (64.2857 100.0000) (64.2857 0.0000) +INDEX 53 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (76.1905 100.0000) (28.5714 100.0000) (23.8095 57.1429) + (28.5714 61.9048) (42.8571 66.6667) (57.1428 66.6667) (71.4286 61.9048) + (80.9524 52.3810) (85.7143 38.0952) (85.7143 28.5714) (80.9524 14.2857) + (71.4286 4.7619) (57.1428 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (23.8095 9.5238) (19.0476 19.0476) +INDEX 54 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 23 (78.5714 85.7143) (73.8096 95.2381) (59.5238 100.0000) + (50.0000 100.0000) (35.7143 95.2381) (26.1905 80.9524) (21.4286 57.1429) + (21.4286 33.3333) (26.1905 14.2857) (35.7143 4.7619) (50.0000 0.0000) + (54.7619 0.0000) (69.0476 4.7619) (78.5714 14.2857) (83.3334 28.5714) + (83.3334 33.3333) (78.5714 47.6190) (69.0476 57.1429) (54.7619 61.9048) + (50.0000 61.9048) (35.7143 57.1429) (26.1905 47.6190) (21.4286 33.3333) +INDEX 55 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (85.7143 100.0000) (38.0952 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) +INDEX 56 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 29 (42.8571 100.0000) (28.5714 95.2381) (23.8095 85.7143) + (23.8095 76.1905) (28.5714 66.6667) (38.0952 61.9048) (57.1428 57.1429) + (71.4286 52.3810) (80.9524 42.8571) (85.7143 33.3333) (85.7143 19.0476) + (80.9524 9.5238) (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) + (28.5714 4.7619) (23.8095 9.5238) (19.0476 19.0476) (19.0476 33.3333) + (23.8095 42.8571) (33.3333 52.3810) (47.6190 57.1429) (66.6666 61.9048) + (76.1905 66.6667) (80.9524 76.1905) (80.9524 85.7143) (76.1905 95.2381) + (61.9047 100.0000) (42.8571 100.0000) +INDEX 57 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 23 (83.3334 66.6667) (78.5714 52.3810) (69.0476 42.8571) + (54.7619 38.0952) (50.0000 38.0952) (35.7143 42.8571) (26.1905 52.3810) + (21.4286 66.6667) (21.4286 71.4286) (26.1905 85.7143) (35.7143 95.2381) + (50.0000 100.0000) (54.7619 100.0000) (69.0476 95.2381) (78.5714 85.7143) + (83.3334 66.6667) (83.3334 42.8571) (78.5714 19.0476) (69.0476 4.7619) + (54.7619 0.0000) (45.2381 0.0000) (30.9524 4.7619) (26.1905 14.2857) +INDEX 58 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 66.6667) (47.6191 61.9048) (52.3810 57.1429) + (57.1429 61.9048) (52.3810 66.6667) + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 59 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 66.6667) (47.6191 61.9048) (52.3810 57.1429) + (57.1429 61.9048) (52.3810 66.6667) + OPEN 8 (57.1429 4.7619) (52.3810 0.0000) (47.6191 4.7619) + (52.3810 9.5238) (57.1429 4.7619) (57.1429 -4.7619) (52.3810 -14.2857) + (47.6191 -19.0476) +INDEX 60 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (90.4762 85.7143) (14.2857 42.8571) (90.4762 0.0000) +INDEX 61 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (9.5238 57.1429) (95.2381 57.1429) + OPEN 2 (9.5238 28.5714) (95.2381 28.5714) +INDEX 62 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (14.2857 85.7143) (90.4762 42.8571) (14.2857 0.0000) +INDEX 63 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (23.8095 76.1905) (23.8095 80.9524) (28.5714 90.4762) + (33.3333 95.2381) (42.8571 100.0000) (61.9047 100.0000) (71.4285 95.2381) + (76.1905 90.4762) (80.9524 80.9524) (80.9524 71.4286) (76.1905 61.9048) + (71.4285 57.1429) (52.3809 47.6190) (52.3809 33.3333) + OPEN 5 (52.3809 9.5238) (47.6190 4.7619) (52.3809 0.0000) + (57.1428 4.7619) (52.3809 9.5238) +INDEX 64 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 8 (64.2857 52.3810) (54.7619 57.1429) (45.2381 57.1429) + (40.4762 47.6190) (40.4762 42.8571) (45.2381 33.3333) (54.7619 33.3333) + (64.2857 38.0952) + OPEN 19 (64.2857 57.1429) (64.2857 38.0952) (69.0476 33.3333) + (78.5714 33.3333) (83.3334 42.8571) (83.3334 47.6190) (78.5714 61.9048) + (69.0476 71.4286) (54.7619 76.1905) (50.0000 76.1905) (35.7143 71.4286) + (26.1905 61.9048) (21.4286 47.6190) (21.4286 42.8571) (26.1905 28.5714) + (35.7143 19.0476) (50.0000 14.2857) (54.7619 14.2857) (69.0476 19.0476) +INDEX 65 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 100.0000) (14.2857 0.0000) + OPEN 2 (52.3809 100.0000) (90.4762 0.0000) + OPEN 2 (28.5714 33.3333) (76.1905 33.3333) +INDEX 66 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 9 (19.0476 100.0000) (61.9047 100.0000) (76.1905 95.2381) + (80.9524 90.4762) (85.7143 80.9524) (85.7143 71.4286) (80.9524 61.9048) + (76.1905 57.1429) (61.9047 52.3810) + OPEN 10 (19.0476 52.3810) (61.9047 52.3810) (76.1905 47.6190) + (80.9524 42.8571) (85.7143 33.3333) (85.7143 19.0476) (80.9524 9.5238) + (76.1905 4.7619) (61.9047 0.0000) (19.0476 0.0000) +INDEX 67 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 18 (88.0952 76.1905) (83.3334 85.7143) (73.8096 95.2381) + (64.2857 100.0000) (45.2381 100.0000) (35.7143 95.2381) (26.1905 85.7143) + (21.4286 76.1905) (16.6667 61.9048) (16.6667 38.0952) (21.4286 23.8095) + (26.1905 14.2857) (35.7143 4.7619) (45.2381 0.0000) (64.2857 0.0000) + (73.8096 4.7619) (83.3334 14.2857) (88.0952 23.8095) +INDEX 68 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 12 (19.0476 100.0000) (52.3809 100.0000) (66.6666 95.2381) + (76.1905 85.7143) (80.9524 76.1905) (85.7143 61.9048) (85.7143 38.0952) + (80.9524 23.8095) (76.1905 14.2857) (66.6666 4.7619) (52.3809 0.0000) + (19.0476 0.0000) +INDEX 69 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (21.4286 100.0000) (21.4286 0.0000) + OPEN 2 (21.4286 100.0000) (83.3334 100.0000) + OPEN 2 (21.4286 52.3810) (59.5238 52.3810) + OPEN 2 (21.4286 0.0000) (83.3334 0.0000) +INDEX 70 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (21.4286 100.0000) (21.4286 0.0000) + OPEN 2 (21.4286 100.0000) (83.3334 100.0000) + OPEN 2 (21.4286 52.3810) (59.5238 52.3810) +INDEX 71 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 19 (88.0952 76.1905) (83.3334 85.7143) (73.8096 95.2381) + (64.2857 100.0000) (45.2381 100.0000) (35.7143 95.2381) (26.1905 85.7143) + (21.4286 76.1905) (16.6667 61.9048) (16.6667 38.0952) (21.4286 23.8095) + (26.1905 14.2857) (35.7143 4.7619) (45.2381 0.0000) (64.2857 0.0000) + (73.8096 4.7619) (83.3334 14.2857) (88.0952 23.8095) (88.0952 38.0952) + OPEN 2 (64.2857 38.0952) (88.0952 38.0952) +INDEX 72 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (85.7143 100.0000) (85.7143 0.0000) + OPEN 2 (19.0476 52.3810) (85.7143 52.3810) +INDEX 73 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 0.0000) +INDEX 74 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (76.1905 100.0000) (76.1905 23.8095) (71.4286 9.5238) + (66.6667 4.7619) (57.1429 0.0000) (47.6191 0.0000) (38.0953 4.7619) + (33.3334 9.5238) (28.5715 23.8095) (28.5715 33.3333) +INDEX 75 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (85.7143 100.0000) (19.0476 33.3333) + OPEN 2 (42.8571 57.1429) (85.7143 0.0000) +INDEX 76 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 100.0000) (23.8095 0.0000) + OPEN 2 (23.8095 0.0000) (80.9524 0.0000) +INDEX 77 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 100.0000) (14.2857 0.0000) + OPEN 2 (14.2857 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (90.4762 0.0000) +INDEX 78 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 0.0000) + OPEN 2 (85.7143 100.0000) (85.7143 0.0000) +INDEX 79 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 21 (42.8571 100.0000) (33.3333 95.2381) (23.8095 85.7143) + (19.0476 76.1905) (14.2857 61.9048) (14.2857 38.0952) (19.0476 23.8095) + (23.8095 14.2857) (33.3333 4.7619) (42.8571 0.0000) (61.9047 0.0000) + (71.4286 4.7619) (80.9524 14.2857) (85.7143 23.8095) (90.4762 38.0952) + (90.4762 61.9048) (85.7143 76.1905) (80.9524 85.7143) (71.4286 95.2381) + (61.9047 100.0000) (42.8571 100.0000) +INDEX 80 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 10 (19.0476 100.0000) (61.9047 100.0000) (76.1905 95.2381) + (80.9524 90.4762) (85.7143 80.9524) (85.7143 66.6667) (80.9524 57.1429) + (76.1905 52.3810) (61.9047 47.6190) (19.0476 47.6190) +INDEX 81 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 21 (42.8571 100.0000) (33.3333 95.2381) (23.8095 85.7143) + (19.0476 76.1905) (14.2857 61.9048) (14.2857 38.0952) (19.0476 23.8095) + (23.8095 14.2857) (33.3333 4.7619) (42.8571 0.0000) (61.9047 0.0000) + (71.4286 4.7619) (80.9524 14.2857) (85.7143 23.8095) (90.4762 38.0952) + (90.4762 61.9048) (85.7143 76.1905) (80.9524 85.7143) (71.4286 95.2381) + (61.9047 100.0000) (42.8571 100.0000) + OPEN 2 (57.1428 19.0476) (85.7143 -9.5238) +INDEX 82 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 10 (19.0476 100.0000) (61.9047 100.0000) (76.1905 95.2381) + (80.9524 90.4762) (85.7143 80.9524) (85.7143 71.4286) (80.9524 61.9048) + (76.1905 57.1429) (61.9047 52.3810) (19.0476 52.3810) + OPEN 2 (52.3809 52.3810) (85.7143 0.0000) +INDEX 83 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 20 (85.7143 85.7143) (76.1905 95.2381) (61.9047 100.0000) + (42.8571 100.0000) (28.5714 95.2381) (19.0476 85.7143) (19.0476 76.1905) + (23.8095 66.6667) (28.5714 61.9048) (38.0952 57.1429) (66.6666 47.6190) + (76.1905 42.8571) (80.9524 38.0952) (85.7143 28.5714) (85.7143 14.2857) + (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (19.0476 14.2857) +INDEX 84 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 100.0000) (52.3809 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) +INDEX 85 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (19.0476 100.0000) (19.0476 28.5714) (23.8095 14.2857) + (33.3333 4.7619) (47.6190 0.0000) (57.1428 0.0000) (71.4286 4.7619) + (80.9524 14.2857) (85.7143 28.5714) (85.7143 100.0000) +INDEX 86 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 0.0000) +INDEX 87 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (4.7619 100.0000) (28.5714 0.0000) + OPEN 2 (52.3809 100.0000) (28.5714 0.0000) + OPEN 2 (52.3809 100.0000) (76.1905 0.0000) + OPEN 2 (100.0000 100.0000) (76.1905 0.0000) +INDEX 88 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (85.7143 0.0000) + OPEN 2 (85.7143 100.0000) (19.0476 0.0000) +INDEX 89 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (14.2857 100.0000) (52.3809 52.3810) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 52.3810) +INDEX 90 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (85.7143 100.0000) (19.0476 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) + OPEN 2 (19.0476 0.0000) (85.7143 0.0000) +INDEX 91 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (35.7143 119.0476) (35.7143 -33.3333) + OPEN 2 (40.4762 119.0476) (40.4762 -33.3333) + OPEN 2 (35.7143 119.0476) (69.0476 119.0476) + OPEN 2 (35.7143 -33.3333) (69.0476 -33.3333) +INDEX 92 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (85.7143 -14.2857) +INDEX 93 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (64.2857 119.0476) (64.2857 -33.3333) + OPEN 2 (69.0476 119.0476) (69.0476 -33.3333) + OPEN 2 (35.7143 119.0476) (69.0476 119.0476) + OPEN 2 (35.7143 -33.3333) (69.0476 -33.3333) +INDEX 94 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 109.5238) (14.2857 42.8571) + OPEN 2 (52.3809 109.5238) (90.4762 42.8571) +INDEX 95 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (0.0000 -33.3333) (104.7619 -33.3333) (104.7619 -28.5714) + (0.0000 -28.5714) (0.0000 -33.3333) +INDEX 96 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (42.8572 100.0000) (66.6667 71.4286) + OPEN 3 (42.8572 100.0000) (38.0953 95.2381) (66.6667 71.4286) +INDEX 97 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 66.6667) (80.9524 0.0000) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 98 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 100.0000) (23.8095 0.0000) + OPEN 14 (23.8095 52.3810) (33.3333 61.9048) (42.8571 66.6667) + (57.1428 66.6667) (66.6666 61.9048) (76.1905 52.3810) (80.9524 38.0952) + (80.9524 28.5714) (76.1905 14.2857) (66.6666 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (33.3333 4.7619) (23.8095 14.2857) +INDEX 99 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 100 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 100.0000) (80.9524 0.0000) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 101 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (23.8095 38.0952) (80.9524 38.0952) (80.9524 47.6190) + (76.1905 57.1429) (71.4285 61.9048) (61.9047 66.6667) (47.6190 66.6667) + (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) (23.8095 28.5714) + (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) (61.9047 0.0000) + (71.4285 4.7619) (80.9524 14.2857) +INDEX 102 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (71.4286 100.0000) (61.9048 100.0000) (52.3810 95.2381) + (47.6191 80.9524) (47.6191 0.0000) + OPEN 2 (33.3334 66.6667) (66.6667 66.6667) +INDEX 103 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 7 (80.9524 66.6667) (80.9524 -9.5238) (76.1905 -23.8095) + (71.4285 -28.5714) (61.9047 -33.3333) (47.6190 -33.3333) (38.0952 -28.5714) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 104 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 100.0000) (26.1905 0.0000) + OPEN 7 (26.1905 47.6190) (40.4762 61.9048) (50.0000 66.6667) + (64.2857 66.6667) (73.8095 61.9048) (78.5715 47.6190) (78.5715 0.0000) +INDEX 105 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (47.6191 100.0000) (52.3810 95.2381) (57.1429 100.0000) + (52.3810 104.7619) (47.6191 100.0000) + OPEN 2 (52.3810 66.6667) (52.3810 0.0000) +INDEX 106 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (57.1429 100.0000) (61.9048 95.2381) (66.6667 100.0000) + (61.9048 104.7619) (57.1429 100.0000) + OPEN 5 (61.9048 66.6667) (61.9048 -14.2857) (57.1429 -28.5714) + (47.6191 -33.3333) (38.0953 -33.3333) +INDEX 107 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 100.0000) (26.1905 0.0000) + OPEN 2 (73.8095 66.6667) (26.1905 19.0476) + OPEN 2 (45.2381 38.0952) (78.5715 0.0000) +INDEX 108 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 0.0000) +INDEX 109 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) + OPEN 7 (52.3810 47.6190) (66.6667 61.9048) (76.1905 66.6667) + (90.4762 66.6667) (100.0000 61.9048) (104.7619 47.6190) (104.7619 0.0000) +INDEX 110 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (26.1905 0.0000) + OPEN 7 (26.1905 47.6190) (40.4762 61.9048) (50.0000 66.6667) + (64.2857 66.6667) (73.8095 61.9048) (78.5715 47.6190) (78.5715 0.0000) +INDEX 111 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (45.2381 66.6667) (35.7143 61.9048) (26.1905 52.3810) + (21.4286 38.0952) (21.4286 28.5714) (26.1905 14.2857) (35.7143 4.7619) + (45.2381 0.0000) (59.5238 0.0000) (69.0476 4.7619) (78.5714 14.2857) + (83.3334 28.5714) (83.3334 38.0952) (78.5714 52.3810) (69.0476 61.9048) + (59.5238 66.6667) (45.2381 66.6667) +INDEX 112 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 66.6667) (23.8095 -33.3333) + OPEN 14 (23.8095 52.3810) (33.3333 61.9048) (42.8571 66.6667) + (57.1428 66.6667) (66.6666 61.9048) (76.1905 52.3810) (80.9524 38.0952) + (80.9524 28.5714) (76.1905 14.2857) (66.6666 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (33.3333 4.7619) (23.8095 14.2857) +INDEX 113 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 66.6667) (80.9524 -33.3333) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 114 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (33.3334 66.6667) (33.3334 0.0000) + OPEN 5 (33.3334 38.0952) (38.0953 52.3810) (47.6191 61.9048) + (57.1429 66.6667) (71.4286 66.6667) +INDEX 115 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (78.5715 52.3810) (73.8095 61.9048) (59.5238 66.6667) + (45.2381 66.6667) (30.9524 61.9048) (26.1905 52.3810) (30.9524 42.8571) + (40.4762 38.0952) (64.2857 33.3333) (73.8095 28.5714) (78.5715 19.0476) + (78.5715 14.2857) (73.8095 4.7619) (59.5238 0.0000) (45.2381 0.0000) + (30.9524 4.7619) (26.1905 14.2857) +INDEX 116 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (47.6191 100.0000) (47.6191 19.0476) (52.3810 4.7619) + (61.9048 0.0000) (71.4286 0.0000) + OPEN 2 (33.3334 66.6667) (66.6667 66.6667) +INDEX 117 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 7 (26.1905 66.6667) (26.1905 19.0476) (30.9524 4.7619) + (40.4762 0.0000) (54.7619 0.0000) (64.2857 4.7619) (78.5715 19.0476) + OPEN 2 (78.5715 66.6667) (78.5715 0.0000) +INDEX 118 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 66.6667) (52.3809 0.0000) + OPEN 2 (80.9524 66.6667) (52.3809 0.0000) +INDEX 119 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 66.6667) (33.3333 0.0000) + OPEN 2 (52.3809 66.6667) (33.3333 0.0000) + OPEN 2 (52.3809 66.6667) (71.4286 0.0000) + OPEN 2 (90.4762 66.6667) (71.4286 0.0000) +INDEX 120 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (78.5715 0.0000) + OPEN 2 (78.5715 66.6667) (26.1905 0.0000) +INDEX 121 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (54.7619 0.0000) + OPEN 6 (83.3334 66.6667) (54.7619 0.0000) (45.2381 -19.0476) + (35.7143 -28.5714) (26.1905 -33.3333) (21.4286 -33.3333) +INDEX 122 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (78.5715 66.6667) (26.1905 0.0000) + OPEN 2 (26.1905 66.6667) (78.5715 66.6667) + OPEN 2 (26.1905 0.0000) (78.5715 0.0000) +INDEX 123 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (64.2857 119.0476) (54.7619 114.2857) (50.0000 109.5238) + (45.2381 100.0000) (45.2381 90.4762) (50.0000 80.9524) (54.7619 76.1905) + (59.5238 66.6667) (59.5238 57.1429) (50.0000 47.6190) + OPEN 17 (54.7619 114.2857) (50.0000 104.7619) (50.0000 95.2381) + (54.7619 85.7143) (59.5238 80.9524) (64.2857 71.4286) (64.2857 61.9048) + (59.5238 52.3810) (40.4762 42.8571) (59.5238 33.3333) (64.2857 23.8095) + (64.2857 14.2857) (59.5238 4.7619) (54.7619 0.0000) (50.0000 -9.5238) + (50.0000 -19.0476) (54.7619 -28.5714) + OPEN 10 (50.0000 38.0952) (59.5238 28.5714) (59.5238 19.0476) + (54.7619 9.5238) (50.0000 4.7619) (45.2381 -4.7619) (45.2381 -14.2857) + (50.0000 -23.8095) (54.7619 -28.5714) (64.2857 -33.3333) +INDEX 124 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 119.0476) (52.3810 -33.3333) +INDEX 125 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (40.4762 119.0476) (50.0000 114.2857) (54.7619 109.5238) + (59.5238 100.0000) (59.5238 90.4762) (54.7619 80.9524) (50.0000 76.1905) + (45.2381 66.6667) (45.2381 57.1429) (54.7619 47.6190) + OPEN 17 (50.0000 114.2857) (54.7619 104.7619) (54.7619 95.2381) + (50.0000 85.7143) (45.2381 80.9524) (40.4762 71.4286) (40.4762 61.9048) + (45.2381 52.3810) (64.2857 42.8571) (45.2381 33.3333) (40.4762 23.8095) + (40.4762 14.2857) (45.2381 4.7619) (50.0000 0.0000) (54.7619 -9.5238) + (54.7619 -19.0476) (50.0000 -28.5714) + OPEN 10 (54.7619 38.0952) (45.2381 28.5714) (45.2381 19.0476) + (50.0000 9.5238) (54.7619 4.7619) (59.5238 -4.7619) (59.5238 -14.2857) + (54.7619 -23.8095) (50.0000 -28.5714) (40.4762 -33.3333) +INDEX 126 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 11 (9.5238 28.5714) (9.5238 38.0952) (14.2857 52.3810) + (23.8095 57.1429) (33.3333 57.1429) (42.8571 52.3810) (61.9048 38.0952) + (71.4286 33.3333) (80.9524 33.3333) (90.4762 38.0952) (95.2381 47.6190) + OPEN 11 (9.5238 38.0952) (14.2857 47.6190) (23.8095 52.3810) + (33.3333 52.3810) (42.8571 47.6190) (61.9048 33.3333) (71.4286 28.5714) + (80.9524 28.5714) (90.4762 33.3333) (95.2381 47.6190) (95.2381 57.1429) +INDEX 127 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (71.4286 100.0000) (33.3333 -33.3333) + OPEN 17 (47.6190 66.6667) (33.3333 61.9048) (23.8095 52.3810) + (19.0476 38.0952) (19.0476 23.8095) (23.8095 14.2857) (33.3333 4.7619) + (47.6190 0.0000) (57.1428 0.0000) (71.4286 4.7619) (80.9524 14.2857) + (85.7143 28.5714) (85.7143 42.8571) (80.9524 52.3810) (71.4286 61.9048) + (57.1428 66.6667) (47.6190 66.6667) diff --git a/gl4java/utils/glut/fonts/Roman.stroke b/gl4java/utils/glut/fonts/Roman.stroke new file mode 100644 index 0000000..d04e957 --- /dev/null +++ b/gl4java/utils/glut/fonts/Roman.stroke @@ -0,0 +1,604 @@ +## +# $XConsortium: Roman.src,v 5.2 91/07/21 16:42:23 rws Exp $ +## +## Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium. +## +## All Rights Reserved +## +## Permission to use, copy, modify, and distribute this software and its +## documentation for any purpose and without fee is hereby granted, +## provided that the above copyright notice appear in all copies and that +## both that copyright notice and this permission notice appear in +## supporting documentation, and that the names of Sun Microsystems, +## the X Consortium, and MIT not be used in advertising or publicity +## pertaining to distribution of the software without specific, written +## prior permission. +## +## SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +## INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +## EVENT SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +## CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +## USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +## OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +## PERFORMANCE OF THIS SOFTWARE. + +# Roman Simplex font. + + FONTNAME Roman + TOP 119.0476 + BOTTOM -33.3333 + NUM_CH 128 + PROPERTIES 3 + + (CHARSET_REGISTRY ISO8859) + (CHARSET_ENCODING "1") + (SPACING P) + +INDEX 32 STROKE 0 CENTER 52.3810 RIGHT 104.7619 +INDEX 33 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 2 (4.7619 100.0000) (4.7619 33.3333) + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 34 STROKE 2 CENTER 19.0476 RIGHT 38.0952 + OPEN 2 (0.0000 100.0000) (0.0000 66.6667) + OPEN 2 (38.0952 100.0000) (38.0952 66.6667) +INDEX 35 STROKE 4 CENTER 33.3333 RIGHT 71.4286 + OPEN 2 (38.0952 119.0476) (4.7619 -33.3333) + OPEN 2 (66.6667 119.0476) (33.3333 -33.3333) + OPEN 2 (4.7619 57.1429) (71.4286 57.1429) + OPEN 2 (0.0000 28.5714) (66.6667 28.5714) +INDEX 36 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (23.8095 119.0476) (23.8095 -19.0476) + OPEN 2 (42.8571 119.0476) (42.8571 -19.0476) + OPEN 20 (66.6667 85.7143) (57.1429 95.2381) (42.8571 100.0000) + (23.8095 100.0000) (9.5238 95.2381) (0.0000 85.7143) (0.0000 76.1905) + (4.7619 66.6667) (9.5238 61.9048) (19.0476 57.1429) (47.6190 47.6190) + (57.1429 42.8571) (61.9048 38.0952) (66.6667 28.5714) (66.6667 14.2857) + (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (0.0000 14.2857) +INDEX 37 STROKE 3 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (85.7143 100.0000) (0.0000 0.0000) + OPEN 16 (23.8095 100.0000) (33.3333 90.4762) (33.3333 80.9524) + (28.5714 71.4286) (19.0476 66.6667) (9.5238 66.6667) (0.0000 76.1905) + (0.0000 85.7143) (4.7619 95.2381) (14.2857 100.0000) (23.8095 100.0000) + (33.3333 95.2381) (47.6190 90.4762) (61.9048 90.4762) (76.1905 95.2381) + (85.7143 100.0000) + OPEN 11 (66.6667 33.3333) (57.1429 28.5714) (52.3810 19.0476) + (52.3810 9.5238) (61.9048 0.0000) (71.4286 0.0000) (80.9524 4.7619) + (85.7143 14.2857) (85.7143 23.8095) (76.1905 33.3333) (66.6667 33.3333) +INDEX 38 STROKE 1 CENTER 47.6190 RIGHT 95.2381 + OPEN 34 (95.2381 57.1429) (95.2381 61.9048) (90.4762 66.6667) + (85.7143 66.6667) (80.9524 61.9048) (76.1905 52.3810) (66.6667 28.5714) + (57.1429 14.2857) (47.6190 4.7619) (38.0952 0.0000) (19.0476 0.0000) + (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) (0.0000 28.5714) + (4.7619 38.0952) (9.5238 42.8571) (42.8571 61.9048) (47.6190 66.6667) + (52.3810 76.1905) (52.3810 85.7143) (47.6190 95.2381) (38.0952 100.0000) + (28.5714 95.2381) (23.8095 85.7143) (23.8095 76.1905) (28.5714 61.9048) + (38.0952 47.6190) (61.9048 14.2857) (71.4286 4.7619) (80.9524 0.0000) + (90.4762 0.0000) (95.2381 4.7619) (95.2381 9.5238) +INDEX 39 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 66.6667) +INDEX 40 STROKE 1 CENTER 14.2857 RIGHT 33.3333 + OPEN 10 (33.3333 119.0476) (23.8095 109.5238) (14.2857 95.2381) + (4.7619 76.1905) (0.0000 52.3810) (0.0000 33.3333) (4.7619 9.5238) + (14.2857 -9.5238) (23.8095 -23.8095) (33.3333 -33.3333) +INDEX 41 STROKE 1 CENTER 19.0476 RIGHT 33.3333 + OPEN 10 (0.0000 119.0476) (9.5238 109.5238) (19.0476 95.2381) + (28.5714 76.1905) (33.3333 52.3810) (33.3333 33.3333) (28.5714 9.5238) + (19.0476 -9.5238) (9.5238 -23.8095) (0.0000 -33.3333) +INDEX 42 STROKE 3 CENTER 23.8095 RIGHT 47.6190 + OPEN 2 (23.8095 71.4286) (23.8095 14.2857) + OPEN 2 (0.0000 57.1429) (47.6190 28.5714) + OPEN 2 (47.6190 57.1429) (0.0000 28.5714) +INDEX 43 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (42.8571 85.7143) (42.8571 0.0000) + OPEN 2 (0.0000 42.8571) (85.7143 42.8571) +INDEX 44 STROKE 1 CENTER 4.7619 RIGHT 9.5238 + OPEN 8 (9.5238 4.7619) (4.7619 0.0000) (0.0000 4.7619) + (4.7619 9.5238) (9.5238 4.7619) (9.5238 -4.7619) (4.7619 -14.2857) + (0.0000 -19.0476) +INDEX 45 STROKE 1 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (0.0000 42.8571) (85.7143 42.8571) +INDEX 46 STROKE 1 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 47 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 -14.2857) (66.6667 100.0000) +INDEX 48 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 17 (28.5714 100.0000) (14.2857 95.2381) (4.7619 80.9524) + (0.0000 57.1429) (0.0000 42.8571) (4.7619 19.0476) (14.2857 4.7619) + (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) (61.9048 19.0476) + (66.6667 42.8571) (66.6667 57.1429) (61.9048 80.9524) (52.3810 95.2381) + (38.0952 100.0000) (28.5714 100.0000) +INDEX 49 STROKE 1 CENTER 19.0476 RIGHT 23.8095 + OPEN 4 (0.0000 80.9524) (9.5238 85.7143) (23.8095 100.0000) + (23.8095 0.0000) +INDEX 50 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 14 (4.7619 76.1905) (4.7619 80.9524) (9.5238 90.4762) + (14.2857 95.2381) (23.8095 100.0000) (42.8571 100.0000) (52.3810 95.2381) + (57.1429 90.4762) (61.9048 80.9524) (61.9048 71.4286) (57.1429 61.9048) + (47.6190 47.6190) (0.0000 0.0000) (66.6667 0.0000) +INDEX 51 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 15 (9.5238 100.0000) (61.9048 100.0000) (33.3333 61.9048) + (47.6190 61.9048) (57.1429 57.1429) (61.9048 52.3810) (66.6667 38.0952) + (66.6667 28.5714) (61.9048 14.2857) (52.3810 4.7619) (38.0952 0.0000) + (23.8095 0.0000) (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) +INDEX 52 STROKE 2 CENTER 33.3333 RIGHT 71.4286 + OPEN 3 (47.6190 100.0000) (0.0000 33.3333) (71.4286 33.3333) + OPEN 2 (47.6190 100.0000) (47.6190 0.0000) +INDEX 53 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 17 (57.1429 100.0000) (9.5238 100.0000) (4.7619 57.1429) + (9.5238 61.9048) (23.8095 66.6667) (38.0952 66.6667) (52.3810 61.9048) + (61.9048 52.3810) (66.6667 38.0952) (66.6667 28.5714) (61.9048 14.2857) + (52.3810 4.7619) (38.0952 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (4.7619 9.5238) (0.0000 19.0476) +INDEX 54 STROKE 1 CENTER 28.5714 RIGHT 61.9048 + OPEN 23 (57.1429 85.7143) (52.3810 95.2381) (38.0952 100.0000) + (28.5714 100.0000) (14.2857 95.2381) (4.7619 80.9524) (0.0000 57.1429) + (0.0000 33.3333) (4.7619 14.2857) (14.2857 4.7619) (28.5714 0.0000) + (33.3333 0.0000) (47.6190 4.7619) (57.1429 14.2857) (61.9048 28.5714) + (61.9048 33.3333) (57.1429 47.6190) (47.6190 57.1429) (33.3333 61.9048) + (28.5714 61.9048) (14.2857 57.1429) (4.7619 47.6190) (0.0000 33.3333) +INDEX 55 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (66.6667 100.0000) (19.0476 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) +INDEX 56 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 29 (23.8095 100.0000) (9.5238 95.2381) (4.7619 85.7143) + (4.7619 76.1905) (9.5238 66.6667) (19.0476 61.9048) (38.0952 57.1429) + (52.3810 52.3810) (61.9048 42.8571) (66.6667 33.3333) (66.6667 19.0476) + (61.9048 9.5238) (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) + (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) (0.0000 33.3333) + (4.7619 42.8571) (14.2857 52.3810) (28.5714 57.1429) (47.6190 61.9048) + (57.1429 66.6667) (61.9048 76.1905) (61.9048 85.7143) (57.1429 95.2381) + (42.8571 100.0000) (23.8095 100.0000) +INDEX 57 STROKE 1 CENTER 33.3333 RIGHT 61.9048 + OPEN 23 (61.9048 66.6667) (57.1429 52.3810) (47.6190 42.8571) + (33.3333 38.0952) (28.5714 38.0952) (14.2857 42.8571) (4.7619 52.3810) + (0.0000 66.6667) (0.0000 71.4286) (4.7619 85.7143) (14.2857 95.2381) + (28.5714 100.0000) (33.3333 100.0000) (47.6190 95.2381) (57.1429 85.7143) + (61.9048 66.6667) (61.9048 42.8571) (57.1429 19.0476) (47.6190 4.7619) + (33.3333 0.0000) (23.8095 0.0000) (9.5238 4.7619) (4.7619 14.2857) +INDEX 58 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 66.6667) (0.0000 61.9048) (4.7619 57.1429) + (9.5238 61.9048) (4.7619 66.6667) + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 59 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 66.6667) (0.0000 61.9048) (4.7619 57.1429) + (9.5238 61.9048) (4.7619 66.6667) + OPEN 8 (9.5238 4.7619) (4.7619 0.0000) (0.0000 4.7619) + (4.7619 9.5238) (9.5238 4.7619) (9.5238 -4.7619) (4.7619 -14.2857) + (0.0000 -19.0476) +INDEX 60 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (76.1905 85.7143) (0.0000 42.8571) (76.1905 0.0000) +INDEX 61 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (0.0000 57.1429) (85.7143 57.1429) + OPEN 2 (0.0000 28.5714) (85.7143 28.5714) +INDEX 62 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (0.0000 85.7143) (76.1905 42.8571) (0.0000 0.0000) +INDEX 63 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 14 (0.0000 76.1905) (0.0000 80.9524) (4.7619 90.4762) + (9.5238 95.2381) (19.0476 100.0000) (38.0952 100.0000) (47.6190 95.2381) + (52.3810 90.4762) (57.1429 80.9524) (57.1429 71.4286) (52.3810 61.9048) + (47.6190 57.1429) (28.5714 47.6190) (28.5714 33.3333) + OPEN 5 (28.5714 9.5238) (23.8095 4.7619) (28.5714 0.0000) + (33.3333 4.7619) (28.5714 9.5238) +INDEX 64 STROKE 2 CENTER 28.5714 RIGHT 61.9048 + OPEN 8 (42.8571 52.3810) (33.3333 57.1429) (23.8095 57.1429) + (19.0476 47.6190) (19.0476 42.8571) (23.8095 33.3333) (33.3333 33.3333) + (42.8571 38.0952) + OPEN 19 (42.8571 57.1429) (42.8571 38.0952) (47.6190 33.3333) + (57.1429 33.3333) (61.9048 42.8571) (61.9048 47.6190) (57.1429 61.9048) + (47.6190 71.4286) (33.3333 76.1905) (28.5714 76.1905) (14.2857 71.4286) + (4.7619 61.9048) (0.0000 47.6190) (0.0000 42.8571) (4.7619 28.5714) + (14.2857 19.0476) (28.5714 14.2857) (33.3333 14.2857) (47.6190 19.0476) +INDEX 65 STROKE 3 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (38.0952 100.0000) (0.0000 0.0000) + OPEN 2 (38.0952 100.0000) (76.1905 0.0000) + OPEN 2 (14.2857 33.3333) (61.9048 33.3333) +INDEX 66 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 9 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 71.4286) (61.9048 61.9048) + (57.1429 57.1429) (42.8571 52.3810) + OPEN 10 (0.0000 52.3810) (42.8571 52.3810) (57.1429 47.6190) + (61.9048 42.8571) (66.6667 33.3333) (66.6667 19.0476) (61.9048 9.5238) + (57.1429 4.7619) (42.8571 0.0000) (0.0000 0.0000) +INDEX 67 STROKE 1 CENTER 33.3333 RIGHT 71.4286 + OPEN 18 (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) +INDEX 68 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 12 (0.0000 100.0000) (33.3333 100.0000) (47.6190 95.2381) + (57.1429 85.7143) (61.9048 76.1905) (66.6667 61.9048) (66.6667 38.0952) + (61.9048 23.8095) (57.1429 14.2857) (47.6190 4.7619) (33.3333 0.0000) + (0.0000 0.0000) +INDEX 69 STROKE 4 CENTER 28.5714 RIGHT 61.9048 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (61.9048 100.0000) + OPEN 2 (0.0000 52.3810) (38.0952 52.3810) + OPEN 2 (0.0000 0.0000) (61.9048 0.0000) +INDEX 70 STROKE 3 CENTER 28.5714 RIGHT 61.9048 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (61.9048 100.0000) + OPEN 2 (0.0000 52.3810) (38.0952 52.3810) +INDEX 71 STROKE 2 CENTER 33.3333 RIGHT 71.4286 + OPEN 19 (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (71.4286 38.0952) + OPEN 2 (47.6190 38.0952) (71.4286 38.0952) +INDEX 72 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (66.6667 100.0000) (66.6667 0.0000) + OPEN 2 (0.0000 52.3810) (66.6667 52.3810) +INDEX 73 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) +INDEX 74 STROKE 1 CENTER 28.5714 RIGHT 47.6190 + OPEN 10 (47.6190 100.0000) (47.6190 23.8095) (42.8571 9.5238) + (38.0952 4.7619) (28.5714 0.0000) (19.0476 0.0000) (9.5238 4.7619) + (4.7619 9.5238) (0.0000 23.8095) (0.0000 33.3333) +INDEX 75 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (66.6667 100.0000) (0.0000 33.3333) + OPEN 2 (23.8095 57.1429) (66.6667 0.0000) +INDEX 76 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 0.0000) (57.1429 0.0000) +INDEX 77 STROKE 4 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (76.1905 0.0000) +INDEX 78 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 0.0000) + OPEN 2 (66.6667 100.0000) (66.6667 0.0000) +INDEX 79 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 21 (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (76.1905 38.0952) + (76.1905 61.9048) (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) +INDEX 80 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 10 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 66.6667) (61.9048 57.1429) + (57.1429 52.3810) (42.8571 47.6190) (0.0000 47.6190) +INDEX 81 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 21 (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (76.1905 38.0952) + (76.1905 61.9048) (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) + OPEN 2 (42.8571 19.0476) (71.4286 -9.5238) +INDEX 82 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 10 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 71.4286) (61.9048 61.9048) + (57.1429 57.1429) (42.8571 52.3810) (0.0000 52.3810) + OPEN 2 (33.3333 52.3810) (66.6667 0.0000) +INDEX 83 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 20 (66.6667 85.7143) (57.1429 95.2381) (42.8571 100.0000) + (23.8095 100.0000) (9.5238 95.2381) (0.0000 85.7143) (0.0000 76.1905) + (4.7619 66.6667) (9.5238 61.9048) (19.0476 57.1429) (47.6190 47.6190) + (57.1429 42.8571) (61.9048 38.0952) (66.6667 28.5714) (66.6667 14.2857) + (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (0.0000 14.2857) +INDEX 84 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (33.3333 100.0000) (33.3333 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) +INDEX 85 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 10 (0.0000 100.0000) (0.0000 28.5714) (4.7619 14.2857) + (14.2857 4.7619) (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) + (61.9048 14.2857) (66.6667 28.5714) (66.6667 100.0000) +INDEX 86 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 0.0000) +INDEX 87 STROKE 4 CENTER 47.6190 RIGHT 95.2381 + OPEN 2 (0.0000 100.0000) (23.8095 0.0000) + OPEN 2 (47.6190 100.0000) (23.8095 0.0000) + OPEN 2 (47.6190 100.0000) (71.4286 0.0000) + OPEN 2 (95.2381 100.0000) (71.4286 0.0000) +INDEX 88 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (66.6667 0.0000) + OPEN 2 (66.6667 100.0000) (0.0000 0.0000) +INDEX 89 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (0.0000 100.0000) (38.0952 52.3810) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 52.3810) +INDEX 90 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (66.6667 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) + OPEN 2 (0.0000 0.0000) (66.6667 0.0000) +INDEX 91 STROKE 4 CENTER 14.2857 RIGHT 33.3333 + OPEN 2 (0.0000 119.0476) (0.0000 -33.3333) + OPEN 2 (4.7619 119.0476) (4.7619 -33.3333) + OPEN 2 (0.0000 119.0476) (33.3333 119.0476) + OPEN 2 (0.0000 -33.3333) (33.3333 -33.3333) +INDEX 92 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (66.6667 -14.2857) +INDEX 93 STROKE 4 CENTER 19.0476 RIGHT 33.3333 + OPEN 2 (28.5714 119.0476) (28.5714 -33.3333) + OPEN 2 (33.3333 119.0476) (33.3333 -33.3333) + OPEN 2 (0.0000 119.0476) (33.3333 119.0476) + OPEN 2 (0.0000 -33.3333) (33.3333 -33.3333) +INDEX 94 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (38.0952 109.5238) (0.0000 42.8571) + OPEN 2 (38.0952 109.5238) (76.1905 42.8571) +INDEX 95 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (0.0000 -33.3333) (104.7619 -33.3333) (104.7619 -28.5714) + (0.0000 -28.5714) (0.0000 -33.3333) +INDEX 96 STROKE 2 CENTER 14.2857 RIGHT 28.5714 + OPEN 2 (4.7619 100.0000) (28.5714 71.4286) + OPEN 3 (4.7619 100.0000) (0.0000 95.2381) (28.5714 71.4286) +INDEX 97 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 66.6667) (57.1429 0.0000) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 98 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 14 (0.0000 52.3810) (9.5238 61.9048) (19.0476 66.6667) + (33.3333 66.6667) (42.8571 61.9048) (52.3810 52.3810) (57.1429 38.0952) + (57.1429 28.5714) (52.3810 14.2857) (42.8571 4.7619) (33.3333 0.0000) + (19.0476 0.0000) (9.5238 4.7619) (0.0000 14.2857) +INDEX 99 STROKE 1 CENTER 28.5714 RIGHT 57.1429 + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 100 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 100.0000) (57.1429 0.0000) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 101 STROKE 1 CENTER 28.5714 RIGHT 57.1429 + OPEN 17 (0.0000 38.0952) (57.1429 38.0952) (57.1429 47.6190) + (52.3810 57.1429) (47.6190 61.9048) (38.0952 66.6667) (23.8095 66.6667) + (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) (0.0000 28.5714) + (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) (38.0952 0.0000) + (47.6190 4.7619) (57.1429 14.2857) +INDEX 102 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 5 (38.0952 100.0000) (28.5714 100.0000) (19.0476 95.2381) + (14.2857 80.9524) (14.2857 0.0000) + OPEN 2 (0.0000 66.6667) (33.3333 66.6667) +INDEX 103 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 7 (57.1429 66.6667) (57.1429 -9.5238) (52.3810 -23.8095) + (47.6190 -28.5714) (38.0952 -33.3333) (23.8095 -33.3333) (14.2857 -28.5714) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 104 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) +INDEX 105 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (0.0000 100.0000) (4.7619 95.2381) (9.5238 100.0000) + (4.7619 104.7619) (0.0000 100.0000) + OPEN 2 (4.7619 66.6667) (4.7619 0.0000) +INDEX 106 STROKE 2 CENTER 19.0476 RIGHT 28.5714 + OPEN 5 (19.0476 100.0000) (23.8095 95.2381) (28.5714 100.0000) + (23.8095 104.7619) (19.0476 100.0000) + OPEN 5 (23.8095 66.6667) (23.8095 -14.2857) (19.0476 -28.5714) + (9.5238 -33.3333) (0.0000 -33.3333) +INDEX 107 STROKE 3 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (47.6190 66.6667) (0.0000 19.0476) + OPEN 2 (19.0476 38.0952) (52.3810 0.0000) +INDEX 108 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) +INDEX 109 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) + OPEN 7 (52.3810 47.6190) (66.6667 61.9048) (76.1905 66.6667) + (90.4762 66.6667) (100.0000 61.9048) (104.7619 47.6190) (104.7619 0.0000) +INDEX 110 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) +INDEX 111 STROKE 1 CENTER 28.5714 RIGHT 61.9048 + OPEN 17 (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) + (0.0000 38.0952) (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) + (23.8095 0.0000) (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) + (61.9048 28.5714) (61.9048 38.0952) (57.1429 52.3810) (47.6190 61.9048) + (38.0952 66.6667) (23.8095 66.6667) +INDEX 112 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 66.6667) (0.0000 -33.3333) + OPEN 14 (0.0000 52.3810) (9.5238 61.9048) (19.0476 66.6667) + (33.3333 66.6667) (42.8571 61.9048) (52.3810 52.3810) (57.1429 38.0952) + (57.1429 28.5714) (52.3810 14.2857) (42.8571 4.7619) (33.3333 0.0000) + (19.0476 0.0000) (9.5238 4.7619) (0.0000 14.2857) +INDEX 113 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 66.6667) (57.1429 -33.3333) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 114 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 5 (0.0000 38.0952) (4.7619 52.3810) (14.2857 61.9048) + (23.8095 66.6667) (38.0952 66.6667) +INDEX 115 STROKE 1 CENTER 23.8095 RIGHT 52.3810 + OPEN 17 (52.3810 52.3810) (47.6190 61.9048) (33.3333 66.6667) + (19.0476 66.6667) (4.7619 61.9048) (0.0000 52.3810) (4.7619 42.8571) + (14.2857 38.0952) (38.0952 33.3333) (47.6190 28.5714) (52.3810 19.0476) + (52.3810 14.2857) (47.6190 4.7619) (33.3333 0.0000) (19.0476 0.0000) + (4.7619 4.7619) (0.0000 14.2857) +INDEX 116 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 5 (14.2857 100.0000) (14.2857 19.0476) (19.0476 4.7619) + (28.5714 0.0000) (38.0952 0.0000) + OPEN 2 (0.0000 66.6667) (33.3333 66.6667) +INDEX 117 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 7 (0.0000 66.6667) (0.0000 19.0476) (4.7619 4.7619) + (14.2857 0.0000) (28.5714 0.0000) (38.0952 4.7619) (52.3810 19.0476) + OPEN 2 (52.3810 66.6667) (52.3810 0.0000) +INDEX 118 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 66.6667) (28.5714 0.0000) + OPEN 2 (57.1429 66.6667) (28.5714 0.0000) +INDEX 119 STROKE 4 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 66.6667) (19.0476 0.0000) + OPEN 2 (38.0952 66.6667) (19.0476 0.0000) + OPEN 2 (38.0952 66.6667) (57.1429 0.0000) + OPEN 2 (76.1905 66.6667) (57.1429 0.0000) +INDEX 120 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 66.6667) (52.3810 0.0000) + OPEN 2 (52.3810 66.6667) (0.0000 0.0000) +INDEX 121 STROKE 2 CENTER 33.3333 RIGHT 61.9048 + OPEN 2 (4.7619 66.6667) (33.3333 0.0000) + OPEN 6 (61.9048 66.6667) (33.3333 0.0000) (23.8095 -19.0476) + (14.2857 -28.5714) (4.7619 -33.3333) (0.0000 -33.3333) +INDEX 122 STROKE 3 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (52.3810 66.6667) (0.0000 0.0000) + OPEN 2 (0.0000 66.6667) (52.3810 66.6667) + OPEN 2 (0.0000 0.0000) (52.3810 0.0000) +INDEX 123 STROKE 3 CENTER 14.2857 RIGHT 23.8095 + OPEN 10 (23.8095 119.0476) (14.2857 114.2857) (9.5238 109.5238) + (4.7619 100.0000) (4.7619 90.4762) (9.5238 80.9524) (14.2857 76.1905) + (19.0476 66.6667) (19.0476 57.1429) (9.5238 47.6190) + OPEN 17 (14.2857 114.2857) (9.5238 104.7619) (9.5238 95.2381) + (14.2857 85.7143) (19.0476 80.9524) (23.8095 71.4286) (23.8095 61.9048) + (19.0476 52.3810) (0.0000 42.8571) (19.0476 33.3333) (23.8095 23.8095) + (23.8095 14.2857) (19.0476 4.7619) (14.2857 0.0000) (9.5238 -9.5238) + (9.5238 -19.0476) (14.2857 -28.5714) + OPEN 10 (9.5238 38.0952) (19.0476 28.5714) (19.0476 19.0476) + (14.2857 9.5238) (9.5238 4.7619) (4.7619 -4.7619) (4.7619 -14.2857) + (9.5238 -23.8095) (14.2857 -28.5714) (23.8095 -33.3333) +INDEX 124 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 119.0476) (0.0000 -33.3333) +INDEX 125 STROKE 3 CENTER 9.5238 RIGHT 23.8095 + OPEN 10 (0.0000 119.0476) (9.5238 114.2857) (14.2857 109.5238) + (19.0476 100.0000) (19.0476 90.4762) (14.2857 80.9524) (9.5238 76.1905) + (4.7619 66.6667) (4.7619 57.1429) (14.2857 47.6190) + OPEN 17 (9.5238 114.2857) (14.2857 104.7619) (14.2857 95.2381) + (9.5238 85.7143) (4.7619 80.9524) (0.0000 71.4286) (0.0000 61.9048) + (4.7619 52.3810) (23.8095 42.8571) (4.7619 33.3333) (0.0000 23.8095) + (0.0000 14.2857) (4.7619 4.7619) (9.5238 0.0000) (14.2857 -9.5238) + (14.2857 -19.0476) (9.5238 -28.5714) + OPEN 10 (14.2857 38.0952) (4.7619 28.5714) (4.7619 19.0476) + (9.5238 9.5238) (14.2857 4.7619) (19.0476 -4.7619) (19.0476 -14.2857) + (14.2857 -23.8095) (9.5238 -28.5714) (0.0000 -33.3333) +INDEX 126 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 11 (0.0000 28.5714) (0.0000 38.0952) (4.7619 52.3810) + (14.2857 57.1429) (23.8095 57.1429) (33.3333 52.3810) (52.3810 38.0952) + (61.9048 33.3333) (71.4286 33.3333) (80.9524 38.0952) (85.7143 47.6190) + OPEN 11 (0.0000 38.0952) (4.7619 47.6190) (14.2857 52.3810) + (23.8095 52.3810) (33.3333 47.6190) (52.3810 33.3333) (61.9048 28.5714) + (71.4286 28.5714) (80.9524 33.3333) (85.7143 47.6190) (85.7143 57.1429) +INDEX 127 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (52.3810 100.0000) (14.2857 -33.3333) + OPEN 17 (28.5714 66.6667) (14.2857 61.9048) (4.7619 52.3810) + (0.0000 38.0952) (0.0000 23.8095) (4.7619 14.2857) (14.2857 4.7619) + (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) (61.9048 14.2857) + (66.6667 28.5714) (66.6667 42.8571) (61.9048 52.3810) (52.3810 61.9048) + (38.0952 66.6667) (28.5714 66.6667) + + + +#/* NCGA GRAFNET:SANS-SERIF NORMAL*/ + +BEARING 32 L_SPACE 0.0 WIDTH 20.0 R_SPACE 0.0 +BEARING 33 L_SPACE 8.62 WIDTH 13.64 R_SPACE 8.48 +BEARING 34 L_SPACE 4.02 WIDTH 32.86 R_SPACE 9.32 +BEARING 35 L_SPACE 3.2 WIDTH 68.94 R_SPACE 4.86 +BEARING 36 L_SPACE 4.82 WIDTH 67.44 R_SPACE 4.72 +BEARING 37 L_SPACE 6.36 WIDTH 112.38 R_SPACE 4.5 +BEARING 38 L_SPACE 5.98 WIDTH 82.02 R_SPACE 0.54 +BEARING 39 L_SPACE 4.44 WIDTH 13.36 R_SPACE 9.18 +BEARING 40 L_SPACE 7.58 WIDTH 24.72 R_SPACE 6.26 +BEARING 41 L_SPACE 5.28 WIDTH 24.34 R_SPACE 8.92 +BEARING 42 L_SPACE 6.96 WIDTH 42.06 R_SPACE 4.86 +BEARING 43 L_SPACE 5.98 WIDTH 96.36 R_SPACE 5.56 +BEARING 44 L_SPACE 8.76 WIDTH 14.2 R_SPACE 7.78 +BEARING 45 L_SPACE 7.38 WIDTH 38.84 R_SPACE 7.66 +BEARING 46 L_SPACE 8.34 WIDTH 13.78 R_SPACE 8.62 +BEARING 47 L_SPACE 7.24 WIDTH 38.44 R_SPACE 8.2 +BEARING 48 L_SPACE 4.98 WIDTH 66.58 R_SPACE 5.42 +BEARING 49 L_SPACE 11.82 WIDTH 34.26 R_SPACE 30.9 +BEARING 50 L_SPACE 5.42 WIDTH 66.0 R_SPACE 5.56 +BEARING 51 L_SPACE 5.0 WIDTH 66.62 R_SPACE 5.38 +BEARING 52 L_SPACE 3.88 WIDTH 68.24 R_SPACE 4.86 +BEARING 53 L_SPACE 4.86 WIDTH 65.96 R_SPACE 6.16 +BEARING 54 L_SPACE 5.58 WIDTH 65.08 R_SPACE 6.32 +BEARING 55 L_SPACE 5.56 WIDTH 66.42 R_SPACE 5.0 +BEARING 56 L_SPACE 5.6 WIDTH 65.98 R_SPACE 5.4 +BEARING 57 L_SPACE 6.6 WIDTH 64.82 R_SPACE 5.56 +BEARING 58 L_SPACE 9.32 WIDTH 14.06 R_SPACE 7.38 +BEARING 59 L_SPACE 8.2 WIDTH 13.96 R_SPACE 8.58 +BEARING 60 L_SPACE 3.06 WIDTH 102.5 R_SPACE 2.36 +BEARING 61 L_SPACE 5.7 WIDTH 96.36 R_SPACE 5.84 +BEARING 62 L_SPACE 2.78 WIDTH 102.5 R_SPACE 2.64 +BEARING 63 L_SPACE 8.42 WIDTH 60.22 R_SPACE 8.34 +BEARING 64 L_SPACE 6.36 WIDTH 126.24 R_SPACE 6.1 +BEARING 65 L_SPACE 2.5 WIDTH 88.16 R_SPACE 1.8 +BEARING 66 L_SPACE 11.42 WIDTH 75.5 R_SPACE 5.54 +BEARING 67 L_SPACE 6.66 WIDTH 87.06 R_SPACE 6.4 +BEARING 68 L_SPACE 11.96 WIDTH 81.48 R_SPACE 6.66 +BEARING 69 L_SPACE 11.42 WIDTH 72.28 R_SPACE 4.86 +BEARING 70 L_SPACE 11.42 WIDTH 67.96 R_SPACE 5.42 +BEARING 71 L_SPACE 7.06 WIDTH 89.56 R_SPACE 11.28 +BEARING 72 L_SPACE 11.42 WIDTH 77.7 R_SPACE 11.0 +BEARING 73 L_SPACE 10.86 WIDTH 13.36 R_SPACE 10.44 +BEARING 74 L_SPACE 2.5 WIDTH 56.96 R_SPACE 9.88 +BEARING 75 L_SPACE 11.28 WIDTH 79.8 R_SPACE 1.38 +BEARING 76 L_SPACE 11.68 WIDTH 62.8 R_SPACE 2.5 +BEARING 77 L_SPACE 10.86 WIDTH 94.56 R_SPACE 10.16 +BEARING 78 L_SPACE 11.14 WIDTH 77.98 R_SPACE 11.0 +BEARING 79 L_SPACE 6.24 WIDTH 95.28 R_SPACE 6.4 +BEARING 80 L_SPACE 12.1 WIDTH 73.44 R_SPACE 6.9 +BEARING 81 L_SPACE 5.3 WIDTH 96.0 R_SPACE 6.6 +BEARING 82 L_SPACE 11.68 WIDTH 80.64 R_SPACE 4.02 +BEARING 83 L_SPACE 8.0 WIDTH 78.28 R_SPACE 6.16 +BEARING 84 L_SPACE 2.36 WIDTH 79.52 R_SPACE 2.92 +BEARING 85 L_SPACE 11.54 WIDTH 77.28 R_SPACE 11.28 +BEARING 86 L_SPACE 2.36 WIDTH 87.04 R_SPACE 3.06 +BEARING 87 L_SPACE 2.22 WIDTH 125.76 R_SPACE 3.06 +BEARING 88 L_SPACE 2.5 WIDTH 86.76 R_SPACE 3.2 +BEARING 89 L_SPACE 1.52 WIDTH 88.98 R_SPACE 1.94 +BEARING 90 L_SPACE 2.5 WIDTH 77.7 R_SPACE 4.58 +BEARING 91 L_SPACE 7.78 WIDTH 25.76 R_SPACE 5.0 +BEARING 92 L_SPACE 5.84 WIDTH 73.24 R_SPACE 5.7 +BEARING 93 L_SPACE 4.44 WIDTH 25.48 R_SPACE 8.62 +BEARING 94 L_SPACE 5.98 WIDTH 55.28 R_SPACE 8.06 +BEARING 95 L_SPACE -1.1 WIDTH 70.04 R_SPACE 0.4 +BEARING 96 L_SPACE 28.26 WIDTH 25.9 R_SPACE 26.74 +BEARING 97 L_SPACE 6.68 WIDTH 67.54 R_SPACE 2.78 +BEARING 98 L_SPACE 8.76 WIDTH 63.66 R_SPACE 4.56 +BEARING 99 L_SPACE 5.52 WIDTH 61.46 R_SPACE 6.26 +BEARING 100 L_SPACE 4.64 WIDTH 63.88 R_SPACE 8.48 +BEARING 101 L_SPACE 5.72 WIDTH 65.62 R_SPACE 5.66 +BEARING 102 L_SPACE 0.68 WIDTH 34.12 R_SPACE -0.12 +BEARING 103 L_SPACE 5.36 WIDTH 63.16 R_SPACE 8.48 +BEARING 104 L_SPACE 9.6 WIDTH 58.34 R_SPACE 9.04 +BEARING 105 L_SPACE 10.02 WIDTH 11.42 R_SPACE 9.32 +BEARING 106 L_SPACE -1.66 WIDTH 23.1 R_SPACE 9.32 +BEARING 107 L_SPACE 9.6 WIDTH 59.18 R_SPACE 0.54 +BEARING 108 L_SPACE 10.02 WIDTH 11.42 R_SPACE 9.32 +BEARING 109 L_SPACE 9.6 WIDTH 96.36 R_SPACE 9.6 +BEARING 110 L_SPACE 9.18 WIDTH 58.48 R_SPACE 9.32 +BEARING 111 L_SPACE 4.98 WIDTH 67.14 R_SPACE 4.86 +BEARING 112 L_SPACE 9.46 WIDTH 63.34 R_SPACE 4.2 +BEARING 113 L_SPACE 4.84 WIDTH 63.38 R_SPACE 8.76 +BEARING 114 L_SPACE 9.46 WIDTH 34.8 R_SPACE 1.94 +BEARING 115 L_SPACE 4.7 WIDTH 59.4 R_SPACE 5.24 +BEARING 116 L_SPACE 0.54 WIDTH 33.42 R_SPACE 0.68 +BEARING 117 L_SPACE 9.46 WIDTH 58.2 R_SPACE 9.32 +BEARING 118 L_SPACE 1.8 WIDTH 65.86 R_SPACE 1.66 +BEARING 119 L_SPACE 2.5 WIDTH 95.82 R_SPACE 1.8 +BEARING 120 L_SPACE 1.66 WIDTH 65.32 R_SPACE 2.36 +BEARING 121 L_SPACE 1.8 WIDTH 65.18 R_SPACE 2.36 +BEARING 122 L_SPACE 4.44 WIDTH 59.88 R_SPACE 5.0 +BEARING 123 L_SPACE 7.38 WIDTH 36.06 R_SPACE 10.44 +BEARING 124 L_SPACE 11.54 WIDTH 6.96 R_SPACE 12.24 +BEARING 125 L_SPACE 9.18 WIDTH 36.2 R_SPACE 8.48 +BEARING 126 L_SPACE 2.92 WIDTH 102.36 R_SPACE 2.64 + diff --git a/gl4java/utils/glut/fonts/StrokeCharRec.java b/gl4java/utils/glut/fonts/StrokeCharRec.java new file mode 100644 index 0000000..f0fdec2 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeCharRec.java @@ -0,0 +1,24 @@ +// Stroke Character Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeCharRec { + public int num_strokes; + public StrokeRec[] stroke; + public float center; + public float right; + + public StrokeCharRec(int n, StrokeRec[] strk, float c, float r) { + num_strokes=n; + stroke=strk; + center=c; + right=r; + } +} diff --git a/gl4java/utils/glut/fonts/StrokeFontRec.java b/gl4java/utils/glut/fonts/StrokeFontRec.java new file mode 100644 index 0000000..0985da9 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeFontRec.java @@ -0,0 +1,25 @@ +// Stroke Font Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeFontRec { + public String name; + public int num_chars; + public StrokeCharRec[] ch; + public float top; + public float bottom; + public StrokeFontRec(String n, int num, StrokeCharRec[] c,float t, float b) { + name=n; + num_chars=num; + ch=c; + top=t; + bottom=b; + } +} diff --git a/gl4java/utils/glut/fonts/StrokeRec.java b/gl4java/utils/glut/fonts/StrokeRec.java new file mode 100644 index 0000000..9bb4214 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeRec.java @@ -0,0 +1,20 @@ +// Stroke Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeRec { + public int num_coords; + public CoordRec[] coord; + + public StrokeRec(int num, CoordRec[] c) { + num_coords=num; + coord=c; + } +} diff --git a/gl4java/utils/glut/fonts/capturexfont.c b/gl4java/utils/glut/fonts/capturexfont.c new file mode 100644 index 0000000..4ce3fd4 --- /dev/null +++ b/gl4java/utils/glut/fonts/capturexfont.c @@ -0,0 +1,371 @@ + +/* Copyright (c) Mark J. Kilgard, 1994. */ + +/* 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. */ + +/* capturexfont.c connects to an X server and downloads a + bitmap font from which a C source file is generated, + encoding the font for GLUT's use. Example usage: + capturexfont.c 9x15 glutBitmap9By15 > glut_9x15.c */ + +/* Adapted to produce Java output + portions copyright 2000 MathCore AB */ + +#include +#include +#include +#include +#include +#include +#include + +#define MAX_GLYPHS_PER_GRAB 512 /* This is big enough for 2^9 + glyph character sets */ + +/* TODO: add command line flag to turn on this (and test it of course) */ +static int win32_bugfix=0; + +static void +outputChar(int num, int width, int height, + int xoff, int yoff, int advance, int data) +{ + if ((width == 0 || height == 0) && win32_bugfix) { + printf(" static final byte[] ch%ddata = { (byte)0x0 };\n", num); + printf(" static final BitmapCharRec ch%d = new BitmapCharRec(", num); + printf("%d,", 0); + printf("%d,", 0); + printf("%d,", xoff); + printf("%d,", yoff); + printf("%d,", advance); + printf("ch%ddata", num); + printf(");\n"); + } else { + printf(" static final BitmapCharRec ch%d = new BitmapCharRec(", num); + printf("%d,", width); + printf("%d,", height); + printf("%d,", xoff); + printf("%d,", yoff); + printf("%d,", advance); + if (data) { + printf("ch%ddata", num); + } else { + printf("zerodata"); + } + printf(");\n"); + } + printf("\n"); +} + +/* Can't just use isprint because it only works for the range + of ASCII characters (ie, TRUE for isascii) and capturexfont + might be run on 16-bit fonts. */ +#define PRINTABLE(ch) (isascii(ch) ? isprint(ch) : 0) + +void +captureXFont(Display * dpy, Font font, char *xfont, char *name) +{ + int first, last, count; + int cnt, len; + Pixmap offscreen; + Window drawable; + XFontStruct *fontinfo; + XImage *image; + GC xgc; + XGCValues values; + int width, height; + int i, j, k; + XCharStruct *charinfo; + XChar2b character; + GLubyte *bitmapData; + int x, y; + int spanLength; + int charWidth, charHeight, maxSpanLength, pixwidth; + int grabList[MAX_GLYPHS_PER_GRAB]; + int glyphsPerGrab = MAX_GLYPHS_PER_GRAB; + int numToGrab; + int rows, pages, byte1, byte2, index; + int nullBitmap; + + drawable = RootWindow(dpy, DefaultScreen(dpy)); + + fontinfo = XQueryFont(dpy, font); + pages = fontinfo->max_char_or_byte2 - fontinfo->min_char_or_byte2 + 1; + first = (fontinfo->min_byte1 << 8) + fontinfo->min_char_or_byte2; + last = (fontinfo->max_byte1 << 8) + fontinfo->max_char_or_byte2; + count = last - first + 1; + + width = fontinfo->max_bounds.rbearing - + fontinfo->min_bounds.lbearing; + height = fontinfo->max_bounds.ascent + + fontinfo->max_bounds.descent; + /* 16-bit fonts have more than one row; indexing into + per_char is trickier. */ + rows = fontinfo->max_byte1 - fontinfo->min_byte1 + 1; + + maxSpanLength = (width + 7) / 8; + /* For portability reasons we don't use alloca for + bitmapData, but we could. */ + bitmapData = malloc(height * maxSpanLength); + /* Be careful determining the width of the pixmap; the X + protocol allows pixmaps of width 2^16-1 (unsigned short + size) but drawing coordinates max out at 2^15-1 (signed + short size). If the width is too large, we need to limit + the glyphs per grab. */ + if ((glyphsPerGrab * 8 * maxSpanLength) >= (1 << 15)) { + glyphsPerGrab = (1 << 15) / (8 * maxSpanLength); + } + pixwidth = glyphsPerGrab * 8 * maxSpanLength; + offscreen = XCreatePixmap(dpy, drawable, pixwidth, height, 1); + + values.font = font; + values.background = 0; + values.foreground = 0; + xgc = XCreateGC(dpy, offscreen, + GCFont | GCBackground | GCForeground, &values); + XFillRectangle(dpy, offscreen, xgc, 0, 0, + 8 * maxSpanLength * glyphsPerGrab, height); + XSetForeground(dpy, xgc, 1); + + numToGrab = 0; + if (fontinfo->per_char == NULL) { + charinfo = &(fontinfo->min_bounds); + charWidth = charinfo->rbearing - charinfo->lbearing; + charHeight = charinfo->ascent + charinfo->descent; + spanLength = (charWidth + 7) / 8; + } + printf("\n// GENERATED FILE -- DO NOT MODIFY\n\n"); + printf("package gl4java.utils.glut.fonts.data;\n\n"); + printf("import gl4java.utils.glut.fonts.*;\n\n"); + /* printf("#include \"glutbitmap.h\"\n\n"); */ + + if (win32_bugfix) { + printf("// This file is generated with the WIN32 bug workaround:\n"); + printf("// Microsoft OpenGL 1.1 bug where glBitmap with\n"); + printf("// a height or width of zero does not advance the raster position\n"); + printf("// as specified by OpenGL. (Cosmo OpenGL does not have this bug.)\n"); + } + + printf("\npublic class %s implements GLUTBitmapFont {\n",name); + + printf(" private static byte[] zerodata={ 0 };\n"); + + for (i = first; count; i++, count--) { + int undefined; + if (rows == 1) { + undefined = (fontinfo->min_char_or_byte2 > i || + fontinfo->max_char_or_byte2 < i); + } else { + byte2 = i & 0xff; + byte1 = i >> 8; + undefined = (fontinfo->min_char_or_byte2 > byte2 || + fontinfo->max_char_or_byte2 < byte2 || + fontinfo->min_byte1 > byte1 || + fontinfo->max_byte1 < byte1); + + } + if (undefined) { + goto PossiblyDoGrab; + } + if (fontinfo->per_char != NULL) { + if (rows == 1) { + index = i - fontinfo->min_char_or_byte2; + } else { + byte2 = i & 0xff; + byte1 = i >> 8; + index = + (byte1 - fontinfo->min_byte1) * pages + + (byte2 - fontinfo->min_char_or_byte2); + } + charinfo = &(fontinfo->per_char[index]); + charWidth = charinfo->rbearing - charinfo->lbearing; + charHeight = charinfo->ascent + charinfo->descent; + if (charWidth == 0 || charHeight == 0) { + if (charinfo->width != 0) { + /* Still must move raster pos even if empty character + + */ + outputChar(i, 0, 0, 0, 0, charinfo->width, 0); + } + goto PossiblyDoGrab; + } + } + grabList[numToGrab] = i; + character.byte2 = i & 255; + character.byte1 = i >> 8; + + /* XXX We could use XDrawImageString16 which would also + paint the backing rectangle but X server bugs in some + scalable font rasterizers makes it more effective to do + XFillRectangles to clear the pixmap and then + XDrawImage16 for the text. */ + XDrawString16(dpy, offscreen, xgc, + -charinfo->lbearing + 8 * maxSpanLength * numToGrab, + charinfo->ascent, &character, 1); + + numToGrab++; + + PossiblyDoGrab: + + if (numToGrab >= glyphsPerGrab || count == 1) { + image = XGetImage(dpy, offscreen, + 0, 0, pixwidth, height, 1, XYPixmap); + for (j = numToGrab - 1; j >= 0; j--) { + if (fontinfo->per_char != NULL) { + byte2 = grabList[j] & 0xff; + byte1 = grabList[j] >> 8; + index = + (byte1 - fontinfo->min_byte1) * pages + + (byte2 - fontinfo->min_char_or_byte2); + charinfo = &(fontinfo->per_char[index]); + charWidth = charinfo->rbearing - charinfo->lbearing; + charHeight = charinfo->ascent + charinfo->descent; + spanLength = (charWidth + 7) / 8; + } + memset(bitmapData, 0, height * spanLength); + for (y = 0; y < charHeight; y++) { + for (x = 0; x < charWidth; x++) { + if (XGetPixel(image, j * maxSpanLength * 8 + x, + charHeight - 1 - y)) { + /* Little endian machines (such as DEC Alpha) + could benefit from reversing the bit order + here and changing the GL_UNPACK_LSB_FIRST + parameter in glutBitmapCharacter to GL_TRUE. */ + bitmapData[y * spanLength + x / 8] |= + (1 << (7 - (x & 7))); + } + } + } + if (PRINTABLE(grabList[j])) { + printf("// char: 0x%x '%c'\n\n", + grabList[j], grabList[j]); + } else { + printf("// char: 0x%x\n\n", grabList[j]); + } + + /* Determine if the bitmap is null. */ + nullBitmap = 1; + len = (charinfo->ascent + charinfo->descent) * + ((charinfo->rbearing - charinfo->lbearing + 7) / 8); + cnt = 0; + while (cnt < len) { + for (k = 0; k < 16 && cnt < len; k++, cnt++) { + if (bitmapData[cnt] != 0) { + nullBitmap = 0; + } + } + } + + if (!nullBitmap) { + printf(" static final byte[] ch%ddata = {\n ", grabList[j]); + len = (charinfo->ascent + charinfo->descent) * + ((charinfo->rbearing - charinfo->lbearing + 7) / 8); + cnt = 0; + while (cnt < len) { + for (k = 0; k < 16 && cnt < len; k++, cnt++) { + printf("(byte) 0x%x,", bitmapData[cnt]); + } + printf("\n"); + } + printf(" };\n\n"); + } else { + charWidth = 0; + charHeight = 0; + } + + outputChar(grabList[j], charWidth, charHeight, + -charinfo->lbearing, charinfo->descent, + charinfo->width, !nullBitmap); + } + XDestroyImage(image); + numToGrab = 0; + if (count > 0) { + XSetForeground(dpy, xgc, 0); + XFillRectangle(dpy, offscreen, xgc, 0, 0, + 8 * maxSpanLength * glyphsPerGrab, height); + XSetForeground(dpy, xgc, 1); + } + } + } + XFreeGC(dpy, xgc); + XFreePixmap(dpy, offscreen); + /* For portability reasons we don't use alloca for + bitmapData, but we could. */ + free(bitmapData); + + printf(" static final BitmapCharRec chars[] = {\n"); + for (i = first; i <= last; i++) { + int undefined; + byte2 = i & 0xff; + byte1 = i >> 8; + undefined = (fontinfo->min_char_or_byte2 > byte2 || + fontinfo->max_char_or_byte2 < byte2 || + fontinfo->min_byte1 > byte1 || + fontinfo->max_byte1 < byte1); + if (undefined) { + printf(" null,\n"); + } else { + if (fontinfo->per_char != NULL) { + if (rows == 1) { + index = i - fontinfo->min_char_or_byte2; + } else { + byte2 = i & 0xff; + byte1 = i >> 8; + index = + (byte1 - fontinfo->min_byte1) * pages + + (byte2 - fontinfo->min_char_or_byte2); + } + charinfo = &(fontinfo->per_char[index]); + charWidth = charinfo->rbearing - charinfo->lbearing; + charHeight = charinfo->ascent + charinfo->descent; + if (charWidth == 0 || charHeight == 0) { + if (charinfo->width == 0) { + printf(" null,\n"); + continue; + } + } + } + printf(" ch%d,\n", i); + } + } + printf(" };\n\n"); + printf(" static final BitmapFontRec fontinfo = new BitmapFontRec(\n"); // %s , name + printf(" \"%s\",\n", xfont); + printf(" %d,\n", last - first + 1); + printf(" %d,\n", first); + printf(" chars\n"); + printf(" );\n\n"); + + printf(" public static BitmapFontRec getBitmapFontRec() {\n"); + printf(" return fontinfo;\n"); + printf(" }\n"); + XFreeFont(dpy, fontinfo); + + printf("} // end of class %s\n",name); +} + +int +main(int argc, char **argv) +{ + Display *dpy; + Font font; + + if (argc != 3) { + fprintf(stderr, "usage: capturexfont XFONT NAME\n"); + exit(1); + } + dpy = XOpenDisplay(NULL); + if (dpy == NULL) { + fprintf(stderr, "capturexfont: could not open X display\n"); + exit(1); + } + font = XLoadFont(dpy, argv[1]); + if (font == None) { + fprintf(stderr, "capturexfont: bad font\n"); + exit(1); + } + captureXFont(dpy, font, argv[1], argv[2]); + XCloseDisplay(dpy); + return 0; +} diff --git a/gl4java/utils/glut/fonts/data/glutBitmap8By13.java b/gl4java/utils/glut/fonts/data/glutBitmap8By13.java new file mode 100644 index 0000000..5abf8c5 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmap8By13.java @@ -0,0 +1,2048 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmap8By13 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; + static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,8,zerodata); + +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(6,12,-1,2,8,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(6,10,-1,2,8,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(6,12,-1,2,8,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(6,10,-1,0,8,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(6,10,-1,0,8,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(6,10,-1,0,8,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(6,10,-1,0,8,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,8,-1,1,8,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,7,-1,-1,8,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(6,10,-1,0,8,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(6,10,-1,0,8,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(6,10,-1,0,8,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(6,10,-1,0,8,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(6,10,-1,0,8,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(6,10,-1,0,8,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(6,10,-1,0,8,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,10,-1,0,8,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(5,10,-1,0,8,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,10,-1,0,8,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,10,-1,0,8,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(6,10,-1,0,8,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(6,10,-1,0,8,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(6,10,-1,0,8,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(6,10,-1,0,8,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(6,8,-1,2,8,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x6c, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,8,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(6,10,-1,0,8,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,8,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,8,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,8,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,8,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(6,9,-1,1,8,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(5,10,-1,0,8,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,10,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,10,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,10,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(6,11,-1,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(6,6,-1,-1,8,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(7,10,0,0,8,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(7,10,0,0,8,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x24,(byte) 0x18, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(7,10,0,0,8,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(7,10,0,0,8,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x8,(byte) 0x10, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(7,10,0,0,8,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xe2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,9,0,0,8,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(5,10,-1,0,8,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(5,10,-1,0,8,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(5,10,-1,0,8,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(5,10,-1,0,8,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(6,10,-1,0,8,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(6,10,-1,0,8,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(6,10,-1,0,8,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(6,10,-1,0,8,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,11,-1,2,8,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0xf0,(byte) 0x9c,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(7,9,0,0,8,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(6,10,-1,0,8,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(6,10,-1,0,8,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(6,10,-1,0,8,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(6,10,-1,0,8,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(6,10,-1,0,8,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(6,10,-1,0,8,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(6,9,-1,0,8,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,10,0,0,8,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,10,0,0,8,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,10,0,0,8,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,7,0,-1,8,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(4,6,-1,-3,8,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,8,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(2,2,-3,2,8,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,1,-3,-4,8,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,9,-1,0,8,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0xb4,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(6,7,-1,1,8,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,-3,-8,8,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,8,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,8,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,-1,8,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-2,-5,8,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-8,8,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xaa,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,9,0,-1,8,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,8,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-1,8,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,7,0,-1,8,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x70, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-1,-2,8,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x92,(byte) 0xaa,(byte) 0xa2,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,9,0,-1,8,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xd8, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(5,1,-1,-8,8,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(4,10,-2,0,8,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,9,-3,0,8,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(7,9,0,0,8,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(6,6,-1,-1,8,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(7,9,0,0,8,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,8,-1,-1,8,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,9,-3,0,8,ch161data); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x90,(byte) 0xa8,(byte) 0x48, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(5,3,-1,-6,8,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(5,9,-1,0,8,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,9,-3,0,8,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(5,9,-2,0,8,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfc,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xfc, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(6,6,-1,0,8,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,8,-1,2,8,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(6,6,-1,0,8,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,6,-1,0,8,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(6,6,-1,0,8,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x38,(byte) 0x44,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(6,8,-1,0,8,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x78,(byte) 0x84,(byte) 0x18,(byte) 0x60,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(6,6,-1,0,8,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0xb8, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(6,6,-1,0,8,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x74, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(6,8,-1,2,8,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0xc4,(byte) 0xb8, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(6,8,-1,2,8,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(6,6,-1,0,8,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(6,6,-1,0,8,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(5,9,-1,0,8,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(6,9,-1,0,8,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x18,(byte) 0x0,(byte) 0x8, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(5,10,-1,2,8,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(5,8,-1,0,8,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(6,9,-1,0,8,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x78,(byte) 0x84,(byte) 0x78,(byte) 0x80,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x74, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(6,8,-1,2,8,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(6,9,-1,0,8,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(6,6,-1,0,8,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x74,(byte) 0x4,(byte) 0x4,(byte) 0x4, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(6,9,-1,0,8,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(6,6,-1,0,8,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(6,9,-1,0,8,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(6,6,-1,0,8,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x10,(byte) 0x60,(byte) 0xe0, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(4,3,-2,-6,8,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,1,8,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,3,-1,-6,8,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,9,-1,0,8,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x2,(byte) 0x2,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,9,0,0,8,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,9,-2,0,8,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(6,9,-1,0,8,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,9,0,0,8,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,9,0,0,8,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(7,9,0,0,8,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,9,0,0,8,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,8,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x4,(byte) 0x78,(byte) 0x94,(byte) 0xa4,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(6,10,-1,1,8,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,9,-1,0,8,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x94,(byte) 0xa4,(byte) 0xc4,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(6,9,-1,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,9,0,0,8,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(6,9,-1,0,8,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(6,9,-1,0,8,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3c, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(6,9,-1,0,8,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(5,9,-1,0,8,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(6,9,-1,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,9,-1,0,8,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,9,0,0,8,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,9,-1,0,8,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(7,9,0,0,8,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(6,9,-1,0,8,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x78,(byte) 0x80,(byte) 0x94,(byte) 0xac,(byte) 0xa4,(byte) 0x9c,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(6,9,-1,0,8,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(6,9,-1,0,8,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(5,9,-1,0,8,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xfc, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(6,4,-1,-2,8,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(5,9,-2,0,8,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(4,8,-1,1,8,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(3,8,-2,1,8,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(6,9,-1,0,8,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(6,9,-1,0,8,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(6,9,-1,0,8,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(6,9,-1,0,8,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(6,9,-1,0,8,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x18,(byte) 0x8, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(6,9,-1,0,8,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x38,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(6,9,-1,0,8,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(6,9,-1,0,8,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(5,9,-1,0,8,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x30,(byte) 0x48,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(6,9,-1,0,8,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(7,9,0,0,8,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(3,3,-2,1,8,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(6,1,-1,-4,8,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(4,3,-1,1,8,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-2,8,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x48,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(6,5,-1,-2,8,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,9,-2,0,8,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,9,-3,0,8,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(4,3,-1,-6,8,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x74,(byte) 0x88,(byte) 0x94,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(6,7,-1,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x88,(byte) 0x54,(byte) 0x48,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0x44, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(6,9,-1,0,8,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0xf0,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0x78,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,7,-1,-1,8,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,7,-1,-1,8,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-2,-6,8,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-3,0,8,ch33data); + +// char: 0x1f + + static final byte[] ch31data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch31 = new BitmapCharRec(1,1,-3,-3,8,ch31data); + +// char: 0x1e + + static final byte[] ch30data = { + (byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch30 = new BitmapCharRec(7,9,0,0,8,ch30data); + +// char: 0x1d + + static final byte[] ch29data = { + (byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch29 = new BitmapCharRec(7,7,0,0,8,ch29data); + +// char: 0x1c + + static final byte[] ch28data = { + (byte) 0x88,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0xfc, + }; + + static final BitmapCharRec ch28 = new BitmapCharRec(6,6,-1,0,8,ch28data); + +// char: 0x1b + + static final byte[] ch27data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80, + }; + + static final BitmapCharRec ch27 = new BitmapCharRec(7,8,0,0,8,ch27data); + +// char: 0x1a + + static final byte[] ch26data = { + (byte) 0xfe,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2, + }; + + static final BitmapCharRec ch26 = new BitmapCharRec(7,8,0,0,8,ch26data); + +// char: 0x19 + + static final byte[] ch25data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch25 = new BitmapCharRec(1,13,-3,2,8,ch25data); + +// char: 0x18 + + static final byte[] ch24data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff, + }; + + static final BitmapCharRec ch24 = new BitmapCharRec(8,6,0,2,8,ch24data); + +// char: 0x17 + + static final byte[] ch23data = { + (byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch23 = new BitmapCharRec(8,8,0,-3,8,ch23data); + +// char: 0x16 + + static final byte[] ch22data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch22 = new BitmapCharRec(4,13,0,2,8,ch22data); + +// char: 0x15 + + static final byte[] ch21data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch21 = new BitmapCharRec(5,13,-3,2,8,ch21data); + +// char: 0x14 + + static final byte[] ch20data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch20 = new BitmapCharRec(8,1,0,1,8,ch20data); + +// char: 0x13 + + static final byte[] ch19data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch19 = new BitmapCharRec(8,1,0,-1,8,ch19data); + +// char: 0x12 + + static final byte[] ch18data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch18 = new BitmapCharRec(8,1,0,-3,8,ch18data); + +// char: 0x11 + + static final byte[] ch17data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch17 = new BitmapCharRec(8,1,0,-5,8,ch17data); + +// char: 0x10 + + static final byte[] ch16data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch16 = new BitmapCharRec(8,1,0,-7,8,ch16data); + +// char: 0xf + + static final byte[] ch15data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch15 = new BitmapCharRec(8,13,0,2,8,ch15data); + +// char: 0xe + + static final byte[] ch14data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch14 = new BitmapCharRec(5,8,-3,-3,8,ch14data); + +// char: 0xd + + static final byte[] ch13data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch13 = new BitmapCharRec(5,6,-3,2,8,ch13data); + +// char: 0xc + + static final byte[] ch12data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch12 = new BitmapCharRec(4,6,0,2,8,ch12data); + +// char: 0xb + + static final byte[] ch11data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch11 = new BitmapCharRec(4,8,0,-3,8,ch11data); + +// char: 0xa + + static final byte[] ch10data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch10 = new BitmapCharRec(7,9,0,2,8,ch10data); + +// char: 0x9 + + static final byte[] ch9data = { + (byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88, + }; + + static final BitmapCharRec ch9 = new BitmapCharRec(7,9,0,2,8,ch9data); + +// char: 0x8 + + static final byte[] ch8data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch8 = new BitmapCharRec(7,6,0,0,8,ch8data); + +// char: 0x7 + + static final byte[] ch7data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-1,-5,8,ch7data); + +// char: 0x6 + + static final byte[] ch6data = { + (byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch6 = new BitmapCharRec(7,9,0,2,8,ch6data); + +// char: 0x5 + + static final byte[] ch5data = { + (byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78, + }; + + static final BitmapCharRec ch5 = new BitmapCharRec(7,9,0,2,8,ch5data); + +// char: 0x4 + + static final byte[] ch4data = { + (byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x9e,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch4 = new BitmapCharRec(7,9,0,2,8,ch4data); + +// char: 0x3 + + static final byte[] ch3data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch3 = new BitmapCharRec(7,9,0,2,8,ch3data); + +// char: 0x2 + + static final byte[] ch2data = { + (byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa, + }; + + static final BitmapCharRec ch2 = new BitmapCharRec(8,12,0,2,8,ch2data); + +// char: 0x1 + + static final byte[] ch1data = { + (byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch1 = new BitmapCharRec(7,7,0,-1,8,ch1data); + + static final BitmapCharRec chars[] = { + ch0, + ch1, + ch2, + ch3, + ch4, + ch5, + ch6, + ch7, + ch8, + ch9, + ch10, + ch11, + ch12, + ch13, + ch14, + ch15, + ch16, + ch17, + ch18, + ch19, + ch20, + ch21, + ch22, + ch23, + ch24, + ch25, + ch26, + ch27, + ch28, + ch29, + ch30, + ch31, + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "8x13", + 256, + 0, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmap8By13 diff --git a/gl4java/utils/glut/fonts/data/glutBitmap9By15.java b/gl4java/utils/glut/fonts/data/glutBitmap9By15.java new file mode 100644 index 0000000..4cddc0d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmap9By15.java @@ -0,0 +1,2050 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmap9By15 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; + static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,9,zerodata); + +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(6,14,-1,3,9,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(7,12,-1,3,9,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(6,14,-1,3,9,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(7,11,-1,0,9,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(7,11,-1,0,9,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(7,11,-1,0,9,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(7,11,-1,0,9,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x7c,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x7c,(byte) 0x2, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(7,9,-1,1,9,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x10,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(7,9,-1,0,9,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(7,11,-1,0,9,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(7,11,-1,0,9,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(7,11,-1,0,9,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(7,11,-1,0,9,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(7,11,-1,0,9,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(7,11,-1,0,9,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(7,11,-1,0,9,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,11,-2,0,9,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(5,11,-2,0,9,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60,(byte) 0x10, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,11,-2,0,9,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x40, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,11,-2,0,9,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(7,11,-1,0,9,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(7,11,-1,0,9,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(7,11,-1,0,9,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(7,11,-1,0,9,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(7,10,-1,3,9,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6e,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x92,(byte) 0x6c, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,7,-1,0,9,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x24,(byte) 0x18, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(7,11,-1,0,9,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(7,11,-1,0,9,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(7,11,-1,0,9,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(7,11,-1,0,9,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(7,11,-1,0,9,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(7,11,-1,0,9,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(7,9,-1,1,9,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(7,10,-1,0,9,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,11,-1,0,9,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(7,11,-1,0,9,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(7,11,-1,0,9,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(7,11,-1,0,9,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(7,11,-1,0,9,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x7c,(byte) 0xc2,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x86,(byte) 0x7c,(byte) 0x2, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(7,12,-1,1,9,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(7,7,-1,-1,9,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(7,11,-1,0,9,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(7,11,-1,0,9,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(7,11,-1,0,9,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(7,11,-1,0,9,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(7,11,-1,0,9,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,11,-1,0,9,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,10,-1,0,9,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(5,11,-2,0,9,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(5,11,-2,0,9,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x60,(byte) 0x10, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(5,11,-2,0,9,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x30,(byte) 0x40, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(5,11,-2,0,9,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(7,11,-1,0,9,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(7,11,-1,0,9,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(7,11,-1,0,9,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(7,11,-1,0,9,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(7,13,-1,3,9,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xfc,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(7,10,-1,0,9,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,11,-1,0,9,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,11,-1,0,9,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,11,-1,0,9,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,11,-1,0,9,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,11,-1,0,9,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(7,10,-1,0,9,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,10,-1,0,9,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,10,-1,0,9,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,10,-1,0,9,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(5,6,-1,-5,9,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,9,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0x60,(byte) 0x90,(byte) 0x30, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(4,3,-2,3,9,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-4,-4,9,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0x7a,(byte) 0x8a,(byte) 0x8a,(byte) 0x8a,(byte) 0x7e, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(7,10,-1,0,9,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xba,(byte) 0xc6,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(7,9,-1,2,9,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0xc0,(byte) 0x20, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(3,2,-3,-9,9,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,9,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,9,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(7,9,-1,-1,9,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-3,-6,9,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-9,9,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x3c,(byte) 0x42,(byte) 0xa5,(byte) 0xa9,(byte) 0xbd,(byte) 0xa5,(byte) 0xb9,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(8,9,0,-1,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,9,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,9,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x90,(byte) 0x70,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-3,-3,9,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x99,(byte) 0xa5,(byte) 0xa1,(byte) 0xa5,(byte) 0x99,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(8,9,0,-1,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,2,-3,-9,9,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,11,-2,1,9,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-4,1,9,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(7,10,-1,0,9,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x82, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(7,6,-1,-3,9,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(7,10,-1,0,9,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x78,(byte) 0xa4,(byte) 0xa0,(byte) 0x90,(byte) 0x94,(byte) 0x78,(byte) 0x8, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(6,8,-1,0,9,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,11,-4,0,9,ch161data); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x8c,(byte) 0x92,(byte) 0x62, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(7,3,-1,-7,9,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(5,12,-1,1,9,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-4,1,9,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(5,12,-3,1,9,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfe, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(7,7,-1,0,9,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,10,-1,3,9,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(7,7,-1,0,9,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,7,-1,0,9,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(7,7,-1,0,9,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(7,7,-1,0,9,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x1c,(byte) 0x22,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xfc,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(7,9,-1,0,9,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x7c,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(7,7,-1,0,9,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x42,(byte) 0x62,(byte) 0x9c, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(7,7,-1,0,9,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(7,10,-1,3,9,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(7,10,-1,3,9,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(7,7,-1,0,9,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(7,7,-1,0,9,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(5,10,-2,0,9,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x82,(byte) 0x8c,(byte) 0xb0,(byte) 0xc0,(byte) 0xb0,(byte) 0x8c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(7,10,-1,0,9,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1c,(byte) 0x0,(byte) 0x0,(byte) 0xc, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(6,13,-1,3,9,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(5,10,-2,0,9,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(7,10,-1,0,9,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x80,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x7a, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(7,10,-1,3,9,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(7,10,-1,0,9,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(7,7,-1,0,9,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a,(byte) 0x2,(byte) 0x2,(byte) 0x2, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(7,10,-1,0,9,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(7,7,-1,0,9,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(7,10,-1,0,9,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(7,7,-1,0,9,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(4,4,-3,-6,9,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(8,1,0,1,9,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(7,4,-1,-6,9,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,12,-2,1,9,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x2,(byte) 0x4,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,10,-1,0,9,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,12,-3,1,9,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(7,10,-1,0,9,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,10,-1,0,9,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,10,-1,0,9,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(7,10,-1,0,9,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,10,-1,0,9,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(7,10,-1,0,9,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,10,-1,0,9,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x2,(byte) 0xc,(byte) 0x70,(byte) 0x80,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(7,10,-1,0,9,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(7,10,-1,0,9,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x6,(byte) 0x8,(byte) 0x7c,(byte) 0x92,(byte) 0xa2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(7,12,-1,2,9,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(7,10,-1,0,9,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(7,10,-1,0,9,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,10,-1,0,9,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,10,-1,0,9,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(7,10,-1,0,9,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x84,(byte) 0x82, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(7,10,-1,0,9,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1e, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(7,10,-1,0,9,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(5,10,-2,0,9,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,10,-1,0,9,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(7,10,-1,0,9,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(7,10,-1,0,9,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(7,10,-1,0,9,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,10,-1,0,9,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(7,10,-1,0,9,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(7,10,-1,0,9,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,10,-1,0,9,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0x9a,(byte) 0xa6,(byte) 0xa2,(byte) 0x9e,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(7,10,-1,0,9,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(7,10,-1,0,9,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(5,10,-2,0,9,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(7,4,-1,-2,9,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(5,10,-2,0,9,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,10,-4,3,9,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,7,-4,0,9,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x78,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(7,10,-1,0,9,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(7,10,-1,0,9,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(7,10,-1,0,9,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x3c, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(7,10,-1,0,9,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0xfe, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(7,10,-1,0,9,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfe,(byte) 0x84,(byte) 0x44,(byte) 0x24,(byte) 0x14,(byte) 0xc,(byte) 0x4, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(7,10,-1,0,9,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x1c,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(7,10,-1,0,9,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(7,10,-1,0,9,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(7,10,-1,0,9,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(7,10,-1,0,9,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(7,10,-1,0,9,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-4,0,9,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(7,1,-1,-4,9,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-4,3,9,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(7,7,-1,-1,9,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x10,(byte) 0x92,(byte) 0x54,(byte) 0x38,(byte) 0x54,(byte) 0x92,(byte) 0x10, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(7,7,-1,-1,9,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,12,-3,1,9,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-3,1,9,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(4,4,-3,-6,9,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x62,(byte) 0x94,(byte) 0x88,(byte) 0x94,(byte) 0x62,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(7,10,-1,0,9,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x84,(byte) 0x4a,(byte) 0x4a,(byte) 0x24,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0xa4,(byte) 0x42, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(7,10,-1,0,9,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x10,(byte) 0x7c,(byte) 0x92,(byte) 0x12,(byte) 0x12,(byte) 0x14,(byte) 0x38,(byte) 0x50,(byte) 0x90,(byte) 0x92,(byte) 0x7c,(byte) 0x10, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(7,12,-1,1,9,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,8,-1,-1,9,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-3,-7,9,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,11,-4,0,9,ch33data); + +// char: 0x1f + + static final byte[] ch31data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch31 = new BitmapCharRec(2,2,-4,-2,9,ch31data); + +// char: 0x1e + + static final byte[] ch30data = { + (byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch30 = new BitmapCharRec(7,10,-1,0,9,ch30data); + +// char: 0x1d + + static final byte[] ch29data = { + (byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch29 = new BitmapCharRec(7,7,-1,0,9,ch29data); + +// char: 0x1c + + static final byte[] ch28data = { + (byte) 0x44,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0xfe, + }; + + static final BitmapCharRec ch28 = new BitmapCharRec(7,7,-1,0,9,ch28data); + +// char: 0x1b + + static final byte[] ch27data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch27 = new BitmapCharRec(7,12,-1,2,9,ch27data); + +// char: 0x1a + + static final byte[] ch26data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch26 = new BitmapCharRec(6,12,-2,2,9,ch26data); + +// char: 0x19 + + static final byte[] ch25data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch25 = new BitmapCharRec(1,15,-4,3,9,ch25data); + +// char: 0x18 + + static final byte[] ch24data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch24 = new BitmapCharRec(9,7,0,3,9,ch24data); + +// char: 0x17 + + static final byte[] ch23data = { + (byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch23 = new BitmapCharRec(9,9,0,-3,9,ch23data); + +// char: 0x16 + + static final byte[] ch22data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch22 = new BitmapCharRec(5,15,0,3,9,ch22data); + +// char: 0x15 + + static final byte[] ch21data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch21 = new BitmapCharRec(5,15,-4,3,9,ch21data); + +// char: 0x14 + + static final byte[] ch20data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch20 = new BitmapCharRec(9,1,0,1,9,ch20data); + +// char: 0x13 + + static final byte[] ch19data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch19 = new BitmapCharRec(9,1,0,-1,9,ch19data); + +// char: 0x12 + + static final byte[] ch18data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch18 = new BitmapCharRec(9,1,0,-3,9,ch18data); + +// char: 0x11 + + static final byte[] ch17data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch17 = new BitmapCharRec(9,1,0,-5,9,ch17data); + +// char: 0x10 + + static final byte[] ch16data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch16 = new BitmapCharRec(9,1,0,-7,9,ch16data); + +// char: 0xf + + static final byte[] ch15data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0, +(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch15 = new BitmapCharRec(9,15,0,3,9,ch15data); + +// char: 0xe + + static final byte[] ch14data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch14 = new BitmapCharRec(5,9,-4,-3,9,ch14data); + +// char: 0xd + + static final byte[] ch13data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch13 = new BitmapCharRec(5,7,-4,3,9,ch13data); + +// char: 0xc + + static final byte[] ch12data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch12 = new BitmapCharRec(5,7,0,3,9,ch12data); + +// char: 0xb + + static final byte[] ch11data = { + (byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch11 = new BitmapCharRec(5,9,0,-3,9,ch11data); + +// char: 0xa + + static final byte[] ch10data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch10 = new BitmapCharRec(7,10,-1,2,9,ch10data); + +// char: 0x9 + + static final byte[] ch9data = { + (byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88, + }; + + static final BitmapCharRec ch9 = new BitmapCharRec(7,10,-1,2,9,ch9data); + +// char: 0x8 + + static final byte[] ch8data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch8 = new BitmapCharRec(7,6,-1,0,9,ch8data); + +// char: 0x7 + + static final byte[] ch7data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-2,-6,9,ch7data); + +// char: 0x6 + + static final byte[] ch6data = { + (byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0x0,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch6 = new BitmapCharRec(7,10,-1,2,9,ch6data); + +// char: 0x5 + + static final byte[] ch5data = { + (byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x0,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78, + }; + + static final BitmapCharRec ch5 = new BitmapCharRec(7,10,-1,2,9,ch5data); + +// char: 0x4 + + static final byte[] ch4data = { + (byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x1e,(byte) 0x80,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch4 = new BitmapCharRec(7,10,-1,2,9,ch4data); + +// char: 0x3 + + static final byte[] ch3data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch3 = new BitmapCharRec(7,10,-1,2,9,ch3data); + +// char: 0x2 + + static final byte[] ch2data = { + (byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa, + }; + + static final BitmapCharRec ch2 = new BitmapCharRec(8,14,0,3,9,ch2data); + +// char: 0x1 + + static final byte[] ch1data = { + (byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch1 = new BitmapCharRec(7,7,-1,0,9,ch1data); + + static final BitmapCharRec chars[] = { + ch0, + ch1, + ch2, + ch3, + ch4, + ch5, + ch6, + ch7, + ch8, + ch9, + ch10, + ch11, + ch12, + ch13, + ch14, + ch15, + ch16, + ch17, + ch18, + ch19, + ch20, + ch21, + ch22, + ch23, + ch24, + ch25, + ch26, + ch27, + ch28, + ch29, + ch30, + ch31, + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "9x15", + 256, + 0, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmap9By15 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java new file mode 100644 index 0000000..a83f7b3 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java @@ -0,0 +1,1769 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica10 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(4,10,0,2,5,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(5,10,0,2,6,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(4,11,0,2,5,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(4,8,0,0,5,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(4,9,0,0,5,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(4,9,0,0,5,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(4,9,0,0,5,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x70,(byte) 0x88,(byte) 0xc8,(byte) 0xa8,(byte) 0x98,(byte) 0x74, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,6,0,0,6,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,-1,6,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(5,8,0,0,6,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(5,9,0,0,6,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(5,9,0,0,6,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(5,9,0,0,6,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(5,9,0,0,6,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(4,9,0,0,5,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x90,(byte) 0x60,(byte) 0x50, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(5,9,0,0,6,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,8,0,0,2,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,9,1,0,2,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(2,9,0,0,2,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(2,9,1,0,2,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(4,8,0,0,5,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(4,9,0,0,5,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(4,9,0,0,5,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(4,9,0,0,5,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(4,8,0,2,5,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7e,(byte) 0x12,(byte) 0xec, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x20,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(5,9,0,0,5,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(5,8,0,0,5,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(5,9,0,0,5,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(5,9,0,0,5,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(5,9,0,0,5,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(5,9,0,0,5,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(4,8,0,0,5,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(5,8,-1,0,7,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,11,0,0,7,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,11,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,11,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,11,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(6,10,-1,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,-1,6,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(6,10,-1,0,8,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(6,11,-1,0,8,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(6,11,-1,0,8,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(6,11,-1,0,8,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(6,11,-1,0,8,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(6,11,-1,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x78,(byte) 0x44,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x44,(byte) 0x78, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,8,0,0,8,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,10,0,0,3,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,11,0,0,3,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(2,11,-1,0,3,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(2,11,0,0,3,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(5,10,-1,0,7,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(5,11,-1,0,7,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(5,11,-1,0,7,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(5,11,-1,0,7,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,10,-1,2,8,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x2f,(byte) 0x80,(byte) 0x28,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(9,8,0,0,10,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,11,0,0,7,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,10,0,0,7,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,11,0,0,7,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,11,0,0,7,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,11,0,0,7,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,11,0,0,7,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(4,8,-1,2,6,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xe2,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(9,8,0,0,9,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x27,(byte) 0x12,(byte) 0x15,(byte) 0xb,(byte) 0x48,(byte) 0x44,(byte) 0xc4,(byte) 0x42, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(8,8,0,0,9,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x42,(byte) 0x0, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(9,8,0,0,9,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(5,5,0,0,6,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-3,4,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(2,4,0,-3,3,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(2,2,0,2,3,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,1,0,-3,3,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,10,0,2,6,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(4,8,0,2,5,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-6,3,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-7,3,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-3,4,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-2,7,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(5,5,0,0,6,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-3,4,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-7,3,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x18,(byte) 0x70,(byte) 0xc8,(byte) 0x98,(byte) 0x70,(byte) 0xc0,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,10,0,2,6,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,10,-1,2,3,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,8,0,0,6,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(4,6,0,-1,5,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xb0,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,8,0,0,6,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,8,0,1,6,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,8,-1,2,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,3,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(3,10,0,2,3,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,10,-1,2,3,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(3,10,0,2,3,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,6,0,0,5,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(4,8,0,2,5,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(5,6,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x28,(byte) 0x28,(byte) 0x54,(byte) 0x54,(byte) 0x92,(byte) 0x92, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,6,0,0,6,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(4,6,0,0,5,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(3,8,0,0,4,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(4,6,0,0,5,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,6,0,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,8,0,2,6,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(5,8,0,2,6,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(5,6,0,0,6,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,6,0,0,6,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(1,8,0,0,2,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(4,8,0,0,5,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(1,9,0,1,2,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(1,8,0,0,2,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,8,0,0,6,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x70,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(5,8,0,2,6,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,8,0,0,4,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(4,6,0,0,5,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,8,0,0,6,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(4,6,0,0,5,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(5,8,0,0,6,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(5,6,0,0,5,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-5,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(6,1,0,2,6,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,5,0,-3,6,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,10,0,2,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(3,8,0,0,3,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,10,-1,2,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(5,8,-1,0,7,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,8,0,0,7,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(5,8,-1,0,7,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(9,8,0,0,9,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,8,0,0,7,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,8,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(5,8,0,0,5,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(5,8,-1,0,7,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(5,8,-1,0,7,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x2,(byte) 0x7c,(byte) 0x8c,(byte) 0x94,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(7,9,-1,1,8,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(5,8,-1,0,7,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,8,-1,0,8,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(6,8,-1,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0xc6,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,8,-1,0,9,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(4,8,-1,0,6,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(5,8,-1,0,7,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(4,8,0,0,5,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(1,8,-1,0,3,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(6,8,-1,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,8,-1,0,8,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(5,8,-1,0,6,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(5,8,-1,0,7,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf0,(byte) 0x88,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(6,8,-1,0,8,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,8,-1,0,8,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(5,8,-1,0,7,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,8,0,0,7,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa4,(byte) 0x80,(byte) 0xa4,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40, +(byte) 0x20,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(10,10,0,2,11,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(4,8,-1,0,6,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(3,5,-1,-1,6,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf0,(byte) 0x0,(byte) 0xf0, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(4,3,0,-2,5,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,-1,6,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(5,8,0,0,6,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(5,8,0,0,6,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(5,8,0,0,6,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(5,8,0,0,6,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(5,8,0,0,6,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(5,8,0,0,6,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(5,8,0,0,6,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(5,8,0,0,6,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(2,8,-1,0,6,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(5,8,0,0,6,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(3,8,0,0,3,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,7,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,3,0,2,3,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,-1,6,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-5,4,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,10,-1,2,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,10,0,2,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-5,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x64,(byte) 0x98,(byte) 0x98,(byte) 0xa4,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(6,8,-1,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x26,(byte) 0x29,(byte) 0x16,(byte) 0x10,(byte) 0x8,(byte) 0x68,(byte) 0x94,(byte) 0x64, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(8,8,0,0,9,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,9,0,1,6,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x28,(byte) 0x7c,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,7,0,0,6,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,2,-1,-6,4,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,8,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,3,zerodata); + + static final BitmapCharRec chars[] = { + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--10-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica10 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java new file mode 100644 index 0000000..0a24726 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java @@ -0,0 +1,1779 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica12 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x50,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(5,12,-1,3,7,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(5,12,-1,3,7,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(5,13,-1,3,7,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(5,9,-1,0,7,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(5,10,-1,0,7,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(5,10,-1,0,7,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(5,10,-1,0,7,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xb8,(byte) 0x44,(byte) 0x64,(byte) 0x54,(byte) 0x4c,(byte) 0x44,(byte) 0x3a, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(7,7,0,0,7,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,-1,-1,7,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(5,9,-1,0,7,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(5,10,-1,0,7,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(5,10,-1,0,7,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(5,10,-1,0,7,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(5,10,-1,0,7,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(5,10,-1,0,7,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x68, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(5,10,-1,0,7,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,9,0,0,3,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,10,0,0,3,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(2,10,-1,0,3,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(2,10,0,0,3,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(5,9,-1,0,7,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(5,10,-1,0,7,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(5,10,-1,0,7,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(5,10,-1,0,7,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(5,10,-1,3,7,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x77,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x77,(byte) 0x0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(9,7,-1,0,11,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,7,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(6,9,-1,0,7,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,7,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,7,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,7,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,7,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(5,9,-1,0,7,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,12,-1,0,9,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,11,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,12,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,12,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,12,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x0,(byte) 0x5e,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x50,(byte) 0x80,(byte) 0x48,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x42,(byte) 0x80, +(byte) 0x21,(byte) 0x0,(byte) 0x1e,(byte) 0x80,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(10,11,0,1,10,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,-1,-1,7,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x24, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(8,11,-1,0,10,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(8,12,-1,0,10,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x14,(byte) 0x8, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(8,12,-1,0,10,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(8,12,-1,0,10,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x10, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(8,12,-1,0,10,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,12,-1,0,9,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7c,(byte) 0x42,(byte) 0x41,(byte) 0x41,(byte) 0xf1,(byte) 0x41,(byte) 0x41,(byte) 0x42,(byte) 0x7c, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(8,9,0,0,9,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,11,0,0,3,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,12,0,0,3,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(2,12,-1,0,3,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(2,12,0,0,3,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(6,11,-1,0,8,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(6,12,-1,0,8,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(6,12,-1,0,8,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(6,12,-1,0,8,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(7,12,-1,3,9,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x4f,(byte) 0x80,(byte) 0x48,(byte) 0x0,(byte) 0x28,(byte) 0x0,(byte) 0x28,(byte) 0x0, +(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(9,9,-1,0,11,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,12,-1,0,9,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,12,-1,0,9,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,12,-1,0,9,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,12,-1,0,9,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,12,-1,0,9,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(5,9,-1,3,7,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0xc9,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x22,(byte) 0x0, +(byte) 0xe1,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(9,9,0,0,10,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x47,(byte) 0x80,(byte) 0x22,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x4b,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0, +(byte) 0x41,(byte) 0x0, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(9,9,0,0,10,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x41,(byte) 0x0,(byte) 0x27,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0, +(byte) 0x41,(byte) 0x0, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(9,9,0,0,10,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(5,5,-1,-1,7,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,-1,-4,5,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(2,5,-1,-3,4,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(3,4,0,3,3,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(1,1,-1,-3,3,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x68,(byte) 0x3c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,12,0,3,7,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(5,10,-1,3,7,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-8,2,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,5,0,-3,4,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,5,0,-3,4,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,0,7,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-4,5,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(4,1,0,-8,4,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x98,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0, +(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(9,9,-1,0,11,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(4,1,0,-3,5,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,8,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(5,5,-1,-1,7,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,-1,-4,5,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x9c,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa0,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0, +(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(9,9,-1,0,11,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-8,3,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x30,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,12,0,3,6,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-1,2,3,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,9,-1,0,7,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(6,6,0,-1,7,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xb0,(byte) 0x48,(byte) 0x20,(byte) 0x20,(byte) 0xf0,(byte) 0x40,(byte) 0x40,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,9,-1,0,7,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x70,(byte) 0xc8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,9,-1,1,7,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,10,-1,3,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,4,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(4,12,0,3,4,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-1,3,3,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(4,12,0,3,4,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,7,-1,0,6,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(5,10,-1,3,7,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(6,7,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(9,7,0,0,9,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,7,-1,0,7,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(5,7,-1,0,7,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(3,9,0,0,3,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(4,7,-1,0,6,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,7,-1,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,10,-1,3,7,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(5,10,-1,3,7,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(5,7,-1,0,7,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,7,-1,0,7,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xda,(byte) 0xa4, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(1,9,-1,0,3,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(5,9,-1,0,6,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(2,12,0,3,3,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(1,9,-1,0,3,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,9,-1,0,7,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(5,10,-1,3,7,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,9,0,0,3,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(5,7,-1,0,7,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,9,-1,0,7,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(5,7,-1,0,7,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(5,9,-1,0,7,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(6,7,-1,0,7,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-6,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,2,7,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,3,0,-5,6,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,12,0,3,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(4,9,0,0,4,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,12,-1,3,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(7,9,-1,0,9,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,9,-1,0,9,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,9,-1,0,9,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, +(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(9,9,-1,0,11,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,9,-1,0,9,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,7,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x18,(byte) 0x60,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x3d,(byte) 0x42,(byte) 0x85,(byte) 0x89,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(8,9,-1,0,10,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(8,9,-1,0,10,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,9,-1,0,9,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(9,9,-1,0,11,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(5,9,-1,0,7,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(7,9,-1,0,8,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(5,9,-1,0,7,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(1,9,-1,0,3,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,9,-1,0,9,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x3a,(byte) 0x46,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(7,9,-1,0,9,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf8,(byte) 0x84,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,9,-1,0,9,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(7,9,-1,0,9,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(6,9,-1,0,8,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,9,-1,0,9,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa6,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40, +(byte) 0x60,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(10,10,-1,1,12,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(5,9,-1,0,7,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(6,5,-1,-1,7,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf8,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(5,3,-1,-2,7,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0xc,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(6,5,0,-1,7,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x78,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(5,9,-1,0,7,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(5,9,-1,0,7,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(5,9,-1,0,7,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(5,9,-1,0,7,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(5,9,-1,0,7,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x28,(byte) 0x18,(byte) 0x8, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(6,9,0,0,7,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(5,9,-1,0,7,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(5,9,-1,0,7,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x20, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(3,9,-1,0,7,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(5,9,-1,0,7,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(4,9,0,0,4,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,8,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,3,-1,2,4,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-1,7,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,-1,-6,5,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,12,0,3,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-1,3,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-6,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x72,(byte) 0x8c,(byte) 0x84,(byte) 0x8a,(byte) 0x50,(byte) 0x30,(byte) 0x48,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(7,9,-1,0,9,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x23,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x14,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x68,(byte) 0x0,(byte) 0x94,(byte) 0x0,(byte) 0x94,(byte) 0x0, +(byte) 0x62,(byte) 0x0, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(9,9,-1,0,11,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,10,-1,1,7,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0x50,(byte) 0xfc,(byte) 0x28,(byte) 0xfc,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,8,0,0,7,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,3,-1,-6,5,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,4,zerodata); + + static final BitmapCharRec chars[] = { + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--12-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica12 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java new file mode 100644 index 0000000..4f5ba1b --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java @@ -0,0 +1,1888 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica18 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66, +(byte) 0x66, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(8,17,-1,4,10,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(9,18,-1,4,11,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18, +(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(8,18,-1,4,10,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x66, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(8,13,-1,0,10,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(8,14,-1,0,10,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(8,14,-1,0,10,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x30, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(8,14,-1,0,10,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xce,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x31,(byte) 0x80,(byte) 0x78,(byte) 0xc0,(byte) 0x6c,(byte) 0xc0,(byte) 0x66,(byte) 0xc0,(byte) 0x63,(byte) 0xc0,(byte) 0x31,(byte) 0x80, +(byte) 0x3f,(byte) 0xc0,(byte) 0xe,(byte) 0x60, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(11,10,0,0,11,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(8,8,-1,-1,10,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x36,(byte) 0x0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(9,13,-1,0,11,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x26,(byte) 0x0,(byte) 0x2d,(byte) 0x0,(byte) 0x19,(byte) 0x0, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(9,14,-1,0,11,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(9,14,-1,0,11,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(9,14,-1,0,11,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(9,14,-1,0,11,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(8,14,-1,0,10,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x4c,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(9,14,-1,0,11,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,13,0,0,4,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc,(byte) 0x78,(byte) 0x30, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(6,14,1,0,4,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(4,14,0,0,4,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(4,14,0,0,4,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x36,(byte) 0x36, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(8,13,-1,0,10,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(8,14,-1,0,10,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(8,14,-1,0,10,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(8,14,-1,0,10,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x78,(byte) 0x6c,(byte) 0xc,(byte) 0x38,(byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(8,14,-1,4,10,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x75,(byte) 0xe0,(byte) 0xef,(byte) 0xf8,(byte) 0xc7,(byte) 0x18,(byte) 0xc6,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0x7f,(byte) 0xf8,(byte) 0xe,(byte) 0x18,(byte) 0xc6,(byte) 0x18, +(byte) 0xef,(byte) 0xf0,(byte) 0x7d,(byte) 0xe0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(13,10,-1,0,15,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x38,(byte) 0x6c,(byte) 0x6c,(byte) 0x38, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(7,14,-1,0,9,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x6c,(byte) 0x6c, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(7,13,-1,0,9,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(7,14,-1,0,9,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(7,14,-1,0,9,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x18,(byte) 0xc, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(7,14,-1,0,9,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(7,14,-1,0,9,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xdc,(byte) 0xde,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xdc,(byte) 0xdc,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0x7c,(byte) 0x38, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(7,14,-1,0,9,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(10,14,-1,0,12,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(12,18,-1,0,14,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(11,17,-1,0,13,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(11,18,-1,0,13,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(11,18,-1,0,13,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(11,18,-1,0,13,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0xc7,(byte) 0xc0,(byte) 0xff,(byte) 0xf0,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x18,(byte) 0x6c,(byte) 0x1c,(byte) 0x6e,(byte) 0xc,(byte) 0x67,(byte) 0xc,(byte) 0x63,(byte) 0x8c, +(byte) 0x61,(byte) 0xcc,(byte) 0x70,(byte) 0xdc,(byte) 0x30,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x1f,(byte) 0xfc,(byte) 0x7,(byte) 0xcc, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(14,14,0,0,15,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80, +(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(10,9,0,0,10,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xd,(byte) 0x80, +(byte) 0xd,(byte) 0x80, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(13,17,-1,0,15,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x9,(byte) 0x80, +(byte) 0xb,(byte) 0x40,(byte) 0x6,(byte) 0x40, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(13,18,-1,0,15,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0xc0, +(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(13,18,-1,0,15,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(13,18,-1,0,15,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(13,18,-1,0,15,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60, +(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0, +(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(11,18,-1,0,13,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7f,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0xfc,(byte) 0x30, +(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0x80, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(12,14,0,0,13,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc, +(byte) 0xcc, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(6,17,0,0,6,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc, +(byte) 0x78,(byte) 0x30, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(6,18,0,0,6,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, +(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(4,18,-2,0,6,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x30, +(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(4,18,0,0,6,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(9,17,-1,0,11,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(9,18,-1,0,11,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(9,18,-1,0,11,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(9,18,-1,0,11,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30, +(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70, +(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(12,18,-1,4,14,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xc1,(byte) 0xff,(byte) 0xc1,(byte) 0xff,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3f,(byte) 0x80,(byte) 0x31,(byte) 0xfe,(byte) 0x31,(byte) 0xfe, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0x7,(byte) 0xff,(byte) 0x7,(byte) 0xff, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(16,14,-1,0,18,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(12,18,0,0,12,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(12,17,0,0,12,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0, +(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(12,18,0,0,12,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(12,18,0,0,12,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(12,18,0,0,12,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(12,18,0,0,12,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0xc6,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(7,14,-1,4,10,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xfc,(byte) 0x6,(byte) 0xd8,(byte) 0x6,(byte) 0x78,(byte) 0x73,(byte) 0x38,(byte) 0xf9,(byte) 0x18,(byte) 0x99,(byte) 0x88, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x98,(byte) 0x60,(byte) 0xf8,(byte) 0x30,(byte) 0x70,(byte) 0x30, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(14,13,0,0,15,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x30,(byte) 0xf8,(byte) 0x30,(byte) 0xf8,(byte) 0x18,(byte) 0x60,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x18,(byte) 0x66,(byte) 0x98,(byte) 0x62,(byte) 0xf8,(byte) 0x63,(byte) 0x70, +(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(13,13,-1,0,15,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x19,(byte) 0xf8,(byte) 0xd,(byte) 0xb0,(byte) 0xc,(byte) 0xf0,(byte) 0x66,(byte) 0x70,(byte) 0x62,(byte) 0x30,(byte) 0x63,(byte) 0x10, +(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(13,13,-1,0,15,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0x88,(byte) 0xd8,(byte) 0x70, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(5,8,-1,-6,7,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,8,-1,-5,6,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xf0,(byte) 0xd8,(byte) 0x18,(byte) 0x70,(byte) 0x60, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(5,5,0,4,5,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-1,-4,4,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x32,(byte) 0x72,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2, +(byte) 0x72,(byte) 0x3f, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(8,18,-1,4,10,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xdb,(byte) 0xff,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(8,14,-1,4,10,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(4,3,0,-11,4,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x70,(byte) 0xf8,(byte) 0x98,(byte) 0x30,(byte) 0x30,(byte) 0x98,(byte) 0xf8,(byte) 0x70, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(5,8,0,-5,6,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf8,(byte) 0xf8,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0x98,(byte) 0xf8,(byte) 0x70, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(5,8,0,-5,6,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(8,11,-1,0,10,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0xd8,(byte) 0x70, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(5,5,-1,-8,7,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(5,1,0,-12,5,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x48,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x89,(byte) 0x8,(byte) 0x8f,(byte) 0x88,(byte) 0x88,(byte) 0x48, +(byte) 0x88,(byte) 0x48,(byte) 0x4f,(byte) 0x90,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(13,13,-1,0,14,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xf8,(byte) 0xf8, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(5,2,-1,-4,7,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(9,5,-1,-3,11,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x68,(byte) 0xd8,(byte) 0x48,(byte) 0x38,(byte) 0xc8,(byte) 0x70, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,8,-1,-6,7,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x47,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8, +(byte) 0x88,(byte) 0x88,(byte) 0x47,(byte) 0x10,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(13,13,-1,0,15,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(5,2,0,-11,6,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xc3,(byte) 0xc3,(byte) 0x7,(byte) 0xe,(byte) 0x3e,(byte) 0x73,(byte) 0xe3,(byte) 0xc3,(byte) 0xc7,(byte) 0x6e,(byte) 0x7c,(byte) 0xf0,(byte) 0xc3,(byte) 0xc3, +(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(8,18,-1,4,10,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-1,3,4,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0x18,(byte) 0xff,(byte) 0x3c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(8,13,-1,0,10,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0xc3,(byte) 0xff,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xff,(byte) 0xc3, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(8,7,-1,-3,10,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xdf,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x60,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x3f,(byte) 0x0,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(9,13,0,0,10,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x10,(byte) 0x10,(byte) 0x3e,(byte) 0x7f,(byte) 0x6b,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0x6b,(byte) 0x7f,(byte) 0x3e,(byte) 0x4,(byte) 0x4, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(8,14,-1,2,10,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(2,14,-2,4,6,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,5,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0xcc,(byte) 0x7e,(byte) 0x33, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(8,3,-1,-4,10,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(6,18,0,4,6,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(2,18,-1,4,4,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x18,(byte) 0xc, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(6,18,0,4,6,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfe,(byte) 0xfe,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x6,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(7,10,-1,0,9,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(8,14,-1,4,10,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xc3,(byte) 0xe7,(byte) 0x66,(byte) 0x3c,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x66,(byte) 0xe7,(byte) 0xc3, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(8,10,-1,0,10,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x39,(byte) 0xc0,(byte) 0x29,(byte) 0x40,(byte) 0x69,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0xc6,(byte) 0x30, +(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(12,10,-1,0,14,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(8,10,-1,0,10,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(8,10,-1,0,10,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x18,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(6,13,0,0,6,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x78,(byte) 0xfc,(byte) 0xc6,(byte) 0x6,(byte) 0x3e,(byte) 0xfc,(byte) 0xc0,(byte) 0xc6,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(7,10,-1,0,9,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(5,10,-1,0,6,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(9,14,-1,4,11,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(9,14,-1,4,11,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(9,10,-1,0,11,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(8,10,-1,0,10,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xe7,(byte) 0x30, +(byte) 0xde,(byte) 0xf0,(byte) 0xcc,(byte) 0x60, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(12,10,-1,0,14,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(2,14,-1,0,4,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0xc7,(byte) 0xc6,(byte) 0xce,(byte) 0xcc,(byte) 0xd8,(byte) 0xf8,(byte) 0xf0,(byte) 0xd8,(byte) 0xcc,(byte) 0xc6,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(8,14,-1,0,9,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0xe0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0, +(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(4,18,1,4,4,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(2,14,-1,0,4,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(8,14,-1,0,10,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x1c,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(9,14,-1,4,11,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x3c,(byte) 0x1c, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(6,14,0,0,6,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(8,10,-1,0,10,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80, +(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(9,14,-1,0,11,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(8,10,-1,0,10,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0, +(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(9,14,-1,0,11,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(7,10,-1,0,9,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,5,-1,-9,4,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(10,2,0,4,10,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x82,(byte) 0xc6,(byte) 0x6c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(7,5,-1,-8,9,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xf0,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,18,0,4,5,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(5,14,0,0,5,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0xf0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xf0,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,18,-1,4,5,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(10,14,-1,0,12,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(12,14,-1,0,14,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1b,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(11,14,-1,0,13,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x1c,(byte) 0x38,(byte) 0x34,(byte) 0x2c,(byte) 0x36,(byte) 0x6c,(byte) 0x36,(byte) 0x6c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0x66, +(byte) 0x62,(byte) 0x46,(byte) 0x63,(byte) 0xc6,(byte) 0xc3,(byte) 0xc3,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(16,14,-1,0,18,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(12,14,-1,0,14,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(11,14,-1,0,13,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(10,14,-1,0,12,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x3f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0,(byte) 0x1f,(byte) 0x0, +(byte) 0x7c,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(11,14,-1,0,13,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(10,14,-1,0,12,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x0,(byte) 0x30,(byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0xf0,(byte) 0x61,(byte) 0xb0,(byte) 0xe1,(byte) 0xb8,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(13,15,-1,1,15,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(10,14,-1,0,12,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(13,14,-1,0,15,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60, +(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(11,14,-1,0,13,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xc3,(byte) 0xc,(byte) 0xc3,(byte) 0xc,(byte) 0xc7,(byte) 0x8c,(byte) 0xc4,(byte) 0x8c,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xd8,(byte) 0x6c,(byte) 0xd8,(byte) 0x6c, +(byte) 0xf0,(byte) 0x3c,(byte) 0xf0,(byte) 0x3c,(byte) 0xe0,(byte) 0x1c,(byte) 0xe0,(byte) 0x1c,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(14,14,-1,0,16,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(8,14,-1,0,10,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xc0,(byte) 0x70,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc7,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0xf8,(byte) 0x0, +(byte) 0xdc,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(12,14,-1,0,13,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(8,14,-1,0,10,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(2,14,-2,0,6,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xff,(byte) 0xe0,(byte) 0xff,(byte) 0xe0, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(11,14,-1,0,13,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xf0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x30,(byte) 0xc1,(byte) 0xf0,(byte) 0xc1,(byte) 0xf0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(12,14,-1,0,14,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(9,14,-1,0,11,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(9,14,-1,0,11,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(11,14,-1,0,13,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(12,14,-1,0,14,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(11,14,-1,0,13,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(12,14,0,0,12,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1f,(byte) 0xf0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x67,(byte) 0x70,(byte) 0xcf,(byte) 0xf8,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x66, +(byte) 0xcc,(byte) 0x66,(byte) 0xcc,(byte) 0x63,(byte) 0xc6,(byte) 0x33,(byte) 0x67,(byte) 0x73,(byte) 0x63,(byte) 0xb3,(byte) 0x30,(byte) 0x6,(byte) 0x1c,(byte) 0xe,(byte) 0xf,(byte) 0xfc, +(byte) 0x3,(byte) 0xf0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(16,17,-1,3,18,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0xc6,(byte) 0xc6,(byte) 0xfe,(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(7,14,-1,0,10,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0xf0,(byte) 0x3c,(byte) 0xe,(byte) 0x3,(byte) 0xe,(byte) 0x3c,(byte) 0xf0,(byte) 0xc0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(8,9,-1,0,10,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfe,(byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(7,6,-2,-2,11,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x3,(byte) 0xf,(byte) 0x3c,(byte) 0x70,(byte) 0xc0,(byte) 0x70,(byte) 0x3c,(byte) 0xf,(byte) 0x3, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(8,9,-1,0,10,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,13,-1,3,5,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,10,-1,0,5,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0x3,(byte) 0x3,(byte) 0x3b,(byte) 0x7f,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc7,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(8,13,-1,0,10,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xe7,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(8,13,-1,0,10,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0x6,(byte) 0x3,(byte) 0xff,(byte) 0xff, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(8,13,-1,0,10,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xfe,(byte) 0xdc,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3c, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(8,13,-1,0,10,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0xc7,(byte) 0xfe,(byte) 0xfc,(byte) 0xc0,(byte) 0xc0,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(8,13,-1,0,10,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x33,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(9,13,-1,0,10,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x1c,(byte) 0x6,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(8,13,-1,0,10,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0x7,(byte) 0x3,(byte) 0xc3,(byte) 0xfe,(byte) 0x3c, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(8,13,-1,0,10,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8,(byte) 0xf8,(byte) 0x18, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(5,13,-2,0,10,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(8,13,-1,0,10,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(5,14,0,0,5,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-1,0,5,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xff,(byte) 0xff, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(8,2,-1,-4,11,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-1,3,5,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(8,10,-1,0,10,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x88,(byte) 0x70,(byte) 0x70,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(5,6,-1,-8,7,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0x60, +(byte) 0xc0,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(4,18,-1,4,6,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60, +(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(4,18,-1,4,6,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,5,-1,-9,4,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x3c,(byte) 0x70,(byte) 0x7e,(byte) 0xe0,(byte) 0xe7,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc3,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0xee,(byte) 0xc0,(byte) 0x7c,(byte) 0x0, +(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x3c,(byte) 0x0, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(12,13,-1,0,13,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x18,(byte) 0x78,(byte) 0x18,(byte) 0xfc,(byte) 0xc,(byte) 0xcc,(byte) 0xc,(byte) 0xcc,(byte) 0x6,(byte) 0xfc,(byte) 0x6,(byte) 0x78,(byte) 0x3,(byte) 0x0,(byte) 0x7b,(byte) 0x0, +(byte) 0xfd,(byte) 0x80,(byte) 0xcd,(byte) 0x80,(byte) 0xcc,(byte) 0xc0,(byte) 0xfc,(byte) 0xc0,(byte) 0x78,(byte) 0x60, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(14,13,-1,0,16,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x9,(byte) 0x80,(byte) 0xf,(byte) 0x0, +(byte) 0x3e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe8,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xcb,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(9,16,-1,2,10,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0, +(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0xc0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(10,13,0,0,10,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0xd8,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(5,5,0,-9,5,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(2,14,-2,0,6,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,5,zerodata); + + static final BitmapCharRec chars[] = { + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--18-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica18 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java new file mode 100644 index 0000000..4c69b9d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java @@ -0,0 +1,1768 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapTimesRoman10 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(5,9,0,2,5,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(4,9,0,2,5,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(5,10,0,2,5,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(5,7,0,0,5,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(5,8,0,0,5,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(5,8,0,0,5,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(5,8,0,0,5,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x38,(byte) 0x4, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,7,1,1,5,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,0,6,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(4,7,0,0,5,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(4,8,0,0,5,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(4,8,0,0,5,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(4,8,0,0,5,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(4,8,0,0,5,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(5,8,0,0,5,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0xa0,(byte) 0x70,(byte) 0x40, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(4,8,0,0,5,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,7,0,0,4,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,8,0,0,4,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(3,8,0,0,4,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(3,8,0,0,4,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(3,7,0,0,4,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(3,8,0,0,4,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(3,8,0,0,4,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(3,8,0,0,4,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(3,8,0,3,4,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0xd8,(byte) 0xa0,(byte) 0x70,(byte) 0x28,(byte) 0xd8, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(5,5,0,0,6,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x40,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(3,8,0,0,4,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(3,7,0,0,4,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(4,8,0,0,4,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(3,8,0,0,4,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(3,8,0,0,4,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(3,8,0,0,4,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xe0,(byte) 0x50,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(4,7,0,0,5,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x70,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(5,7,0,0,6,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,10,0,0,8,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(7,9,0,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(7,10,0,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(7,10,0,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(7,10,0,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x7c,(byte) 0x66,(byte) 0x52,(byte) 0x52,(byte) 0x4a,(byte) 0x66,(byte) 0x3e,(byte) 0x1, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(8,9,0,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,0,6,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(6,9,0,0,7,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(6,10,0,0,7,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(6,10,0,0,7,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(6,10,0,0,7,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(6,10,0,0,7,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0xe4,(byte) 0x44,(byte) 0x4c,(byte) 0xf8, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(6,7,0,0,7,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,9,0,0,4,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,10,0,0,4,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(3,10,0,0,4,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(3,10,0,0,4,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(5,9,0,0,6,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(5,10,0,0,6,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(5,10,0,0,6,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(5,10,0,0,6,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,10,0,3,7,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xef,(byte) 0x49,(byte) 0x78,(byte) 0x2e,(byte) 0x28,(byte) 0x39,(byte) 0x1f, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(8,7,0,0,9,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,10,0,0,8,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,9,0,0,8,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,10,0,0,8,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,10,0,0,8,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,10,0,0,8,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,10,0,0,8,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(3,7,0,2,4,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xd4,(byte) 0x28,(byte) 0x48,(byte) 0xe4, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,7,0,0,8,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x4e,(byte) 0x24,(byte) 0x2a,(byte) 0xf6,(byte) 0x48,(byte) 0xc8,(byte) 0x44, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,7,0,0,8,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xf4,(byte) 0x48,(byte) 0xc8,(byte) 0x44, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,7,0,0,8,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(4,4,0,-1,5,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-2,4,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,4,0,-3,3,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(3,3,0,3,4,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(1,1,0,-2,2,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,9,0,2,6,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(5,7,0,2,5,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-5,3,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-6,4,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-2,4,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-1,7,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x50,(byte) 0xa0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(4,4,0,-1,5,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-2,4,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,-1,-6,5,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x20,(byte) 0x50,(byte) 0x90,(byte) 0xa0,(byte) 0x40,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(4,9,0,1,5,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,7,0,0,2,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x70,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xd8,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,7,0,0,5,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x88,(byte) 0x70,(byte) 0x50,(byte) 0x50,(byte) 0x70,(byte) 0x88, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(5,6,0,-1,5,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xf0,(byte) 0xc8,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x50,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,7,0,0,5,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(4,7,0,1,5,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,7,-1,2,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,2,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-2,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(3,9,0,2,4,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,9,0,2,2,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(3,9,0,2,4,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x90,(byte) 0x40,(byte) 0x20,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,5,0,0,5,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x48,(byte) 0xdc, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,7,1,2,5,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xd8,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0xd8, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(5,5,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x28,(byte) 0x6c,(byte) 0x54,(byte) 0x92,(byte) 0xdb, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(8,5,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x60,(byte) 0x50,(byte) 0x90,(byte) 0xd8, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,5,0,0,5,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(5,5,0,0,5,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(4,6,0,0,4,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0xe0,(byte) 0x20,(byte) 0x60,(byte) 0x80,(byte) 0xe0, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(3,5,0,0,4,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,5,0,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x38,(byte) 0x10,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,7,0,2,5,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(4,7,0,2,5,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(4,5,0,0,5,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,5,0,0,5,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xdb,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(8,5,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(3,7,0,0,4,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x98,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(5,7,0,0,5,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(2,9,0,2,3,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(2,7,0,0,3,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,7,0,0,5,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x60,(byte) 0x40,(byte) 0xa0,(byte) 0xa0,(byte) 0x70, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(4,7,0,2,5,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,7,0,0,4,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(3,5,0,0,4,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0x30, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,7,0,0,5,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(3,5,0,0,4,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(4,7,0,0,5,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(3,5,0,0,4,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0x80, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,2,0,-5,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(5,1,0,3,5,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0xa0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(3,3,-1,-4,5,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,9,0,2,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(3,7,0,0,3,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,9,0,2,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xf8,(byte) 0x88,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x88,(byte) 0xf8, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(5,7,0,0,6,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,7,0,0,8,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xee,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,7,0,0,8,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0xdd,(byte) 0xc0, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(10,7,0,0,10,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x6c,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,7,0,0,8,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(7,7,0,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x70,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa8,(byte) 0xf8, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(5,7,0,0,6,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0xc0,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(4,7,0,0,5,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,7,0,0,7,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0xc,(byte) 0x18,(byte) 0x70,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(6,9,0,2,7,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(5,7,0,0,6,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,7,0,0,7,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,7,0,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xeb,(byte) 0x80,(byte) 0x49,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xe3,(byte) 0x80, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(9,7,0,0,10,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(5,7,0,0,6,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x48,(byte) 0xec, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(6,7,0,0,7,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0xc0,(byte) 0xa0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(4,7,0,0,4,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(3,7,0,0,4,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xee,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,7,0,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x78,(byte) 0xc4,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,7,0,0,7,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(5,7,0,0,6,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(5,7,0,0,6,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x4c,(byte) 0xf8, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(6,7,0,0,7,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,7,0,0,7,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf0,(byte) 0x48,(byte) 0x48,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(5,7,0,0,6,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,7,0,0,8,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x40,(byte) 0x92,(byte) 0xad,(byte) 0xa5,(byte) 0xa5,(byte) 0x9d,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(8,9,0,2,9,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(3,7,0,0,4,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(3,5,0,0,5,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf8,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(5,3,0,-1,6,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,0,5,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(1,7,-1,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,5,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(4,7,0,0,5,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(4,7,0,0,5,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x90,(byte) 0xf0, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(4,7,0,0,5,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(4,7,0,0,5,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0xe0,(byte) 0x40,(byte) 0x70, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(4,7,0,0,5,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(5,7,0,0,5,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(4,7,0,0,5,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(4,7,0,0,5,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(3,7,-1,0,5,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(4,7,0,0,5,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(3,7,0,0,3,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(4,1,-1,-2,7,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(1,3,-1,2,3,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,0,6,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-4,5,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,9,0,2,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,9,0,2,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,2,0,-5,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x76,(byte) 0x8d,(byte) 0x98,(byte) 0x74,(byte) 0x6e,(byte) 0x50,(byte) 0x30, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(8,7,0,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x44,(byte) 0x2a,(byte) 0x2a,(byte) 0x56,(byte) 0xa8,(byte) 0xa4,(byte) 0x7e, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(7,7,0,0,8,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(4,9,0,1,5,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(5,7,0,0,5,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,2,0,-5,4,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,7,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,2,zerodata); + + static final BitmapCharRec chars[] = { + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-times-medium-r-*--10-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapTimesRoman10 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java new file mode 100644 index 0000000..2a00176 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java @@ -0,0 +1,2051 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapTimesRoman24 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(11,21,0,5,11,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(10,22,-1,5,12,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(11,22,0,5,11,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(11,16,-1,0,13,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(11,17,-1,0,13,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80, +(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(11,17,-1,0,13,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(11,17,-1,0,13,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x71,(byte) 0x80,(byte) 0xd0,(byte) 0xc0,(byte) 0xd8,(byte) 0xc0,(byte) 0xc8,(byte) 0xc0,(byte) 0xcc,(byte) 0xc0, +(byte) 0xc4,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(10,14,-1,1,12,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(12,10,-1,-2,14,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(10,16,-1,0,12,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(10,16,-1,0,12,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(10,17,-1,0,12,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80, +(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(10,17,-1,0,12,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(10,17,-1,0,12,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(11,16,-1,0,13,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x71,(byte) 0x80, +(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(10,17,-1,0,12,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(6,16,0,0,6,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x84,(byte) 0x48,(byte) 0x78, +(byte) 0x30, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(6,17,0,0,6,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x80,(byte) 0x60,(byte) 0x38, +(byte) 0x18, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,17,-1,0,6,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,17,0,0,6,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(9,16,-1,0,11,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(9,17,-1,0,11,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(9,17,-1,0,11,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0, +(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(9,17,-1,0,11,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0, +(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80, +(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(9,18,-1,6,11,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x70,(byte) 0xf0,(byte) 0xfb,(byte) 0xf8,(byte) 0xc7,(byte) 0x84,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0xfc, +(byte) 0x3,(byte) 0xc,(byte) 0x63,(byte) 0xc,(byte) 0x67,(byte) 0x98,(byte) 0x3c,(byte) 0xf0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(14,12,-1,0,16,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(9,17,-1,0,11,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(9,16,-1,0,11,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x5c,(byte) 0x0,(byte) 0x3a,(byte) 0x0, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(9,16,-1,0,11,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x42,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x3c,(byte) 0x0, +(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(9,17,-1,0,11,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(9,17,-1,0,11,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0, +(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(9,17,-1,0,11,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xe7,(byte) 0x0,(byte) 0x6c,(byte) 0x80,(byte) 0x6c,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x63,(byte) 0x80, +(byte) 0x67,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(10,17,-1,0,12,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18, +(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0xfc,(byte) 0x0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(13,17,-1,0,15,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0, +(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc, +(byte) 0xfc,(byte) 0x3f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(16,22,0,0,16,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(16,21,-1,0,18,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(16,22,-1,0,18,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(16,22,-1,0,18,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(16,22,-1,0,18,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x20,(byte) 0x0,(byte) 0x27,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x68,(byte) 0x6,(byte) 0x64,(byte) 0x6,(byte) 0xc2,(byte) 0x3,(byte) 0xc2,(byte) 0x3, +(byte) 0xc1,(byte) 0x3,(byte) 0xc1,(byte) 0x3,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x43,(byte) 0x60,(byte) 0x46,(byte) 0x60,(byte) 0x26,(byte) 0x38,(byte) 0x1c, +(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe4,(byte) 0x0,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(16,19,-1,1,18,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x80,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(10,11,-2,-1,14,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x60, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(16,21,-1,0,18,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(16,21,-1,0,18,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(16,22,-1,0,18,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(16,22,-1,0,18,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(16,22,-1,0,18,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84, +(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xf0,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(16,21,-1,0,18,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7f,(byte) 0xe0,(byte) 0x18,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3, +(byte) 0xff,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x38, +(byte) 0x7f,(byte) 0xe0, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(16,17,0,0,17,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(6,21,-1,0,8,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x7e,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, +(byte) 0x7e,(byte) 0x0,(byte) 0x81,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(8,22,-1,0,8,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x40,(byte) 0x30,(byte) 0x1c,(byte) 0xc, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(6,22,-1,0,8,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(6,22,-1,0,8,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(13,21,-1,0,15,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,(byte) 0xc,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(13,22,-1,0,15,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(13,22,-1,0,15,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(13,22,-1,0,15,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38, +(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c,(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(14,23,-1,6,16,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xf9,(byte) 0xff,(byte) 0xf0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x18,(byte) 0x60,(byte) 0x0,(byte) 0x8, +(byte) 0x60,(byte) 0x0,(byte) 0xf,(byte) 0xe0,(byte) 0x80,(byte) 0xc,(byte) 0x60,(byte) 0x80,(byte) 0x4,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60, +(byte) 0x80,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0xe0,(byte) 0x60, +(byte) 0x3,(byte) 0xff,(byte) 0xe0, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(20,17,0,0,21,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(17,21,0,0,17,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(17,21,0,0,17,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x7,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x0,(byte) 0x3,(byte) 0x90,(byte) 0x0, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(17,21,0,0,17,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x1, +(byte) 0x80,(byte) 0x0, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(17,22,0,0,17,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(17,22,0,0,17,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x0,(byte) 0x3, +(byte) 0x0,(byte) 0x0, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(17,22,0,0,17,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x3e,(byte) 0x63,(byte) 0xc1,(byte) 0xc3,(byte) 0xc3,(byte) 0xe0,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0x8,(byte) 0x0,(byte) 0x0,(byte) 0xc, +(byte) 0xc, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(8,17,-1,5,11,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x18,(byte) 0x2,(byte) 0x0,(byte) 0x8,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x22,(byte) 0x0,(byte) 0x6,(byte) 0x32,(byte) 0x0,(byte) 0x3, +(byte) 0x12,(byte) 0x0,(byte) 0x1,(byte) 0xa,(byte) 0x0,(byte) 0x71,(byte) 0x8e,(byte) 0x0,(byte) 0x88,(byte) 0x86,(byte) 0x0,(byte) 0x8c,(byte) 0xc2,(byte) 0x0,(byte) 0xc,(byte) 0x60, +(byte) 0x0,(byte) 0x8,(byte) 0x20,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x8c,(byte) 0x18,(byte) 0x0,(byte) 0x4c,(byte) 0xc,(byte) 0x0, +(byte) 0x38,(byte) 0x4,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(17,17,0,0,18,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x30,(byte) 0x7e,(byte) 0x10,(byte) 0x22,(byte) 0x18,(byte) 0x10,(byte) 0x8,(byte) 0x18,(byte) 0xc,(byte) 0x8,(byte) 0x6,(byte) 0x4,(byte) 0x2,(byte) 0x6,(byte) 0xfb,(byte) 0x46, +(byte) 0x21,(byte) 0x26,(byte) 0x21,(byte) 0x9c,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18, +(byte) 0x20,(byte) 0x8, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(15,17,-1,0,18,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x30,(byte) 0x4,(byte) 0x10,(byte) 0x4,(byte) 0x18,(byte) 0xff,(byte) 0x8,(byte) 0x44,(byte) 0xc,(byte) 0x64,(byte) 0x6,(byte) 0x24,(byte) 0x2,(byte) 0x14,(byte) 0xfb,(byte) 0x1c, +(byte) 0x21,(byte) 0xc,(byte) 0x21,(byte) 0x84,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18, +(byte) 0x20,(byte) 0x8, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(16,17,-1,0,18,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x88,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0, +(byte) 0xcc,(byte) 0x0,(byte) 0x88,(byte) 0x0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(9,10,-2,-1,12,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x78,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(6,9,-1,-8,8,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(5,10,-1,-7,7,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0x78,(byte) 0xcc,(byte) 0xc,(byte) 0x3c,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(6,6,-1,6,8,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-2,-6,6,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0, +(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0xf9,(byte) 0x0, +(byte) 0xf9,(byte) 0x0,(byte) 0xf9,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(9,22,-1,5,11,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x40,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x5c,(byte) 0xe0,(byte) 0x7e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0xe1,(byte) 0xc0, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(11,17,-1,5,13,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x60,(byte) 0x38,(byte) 0x18, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(5,4,-2,-13,8,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8c,(byte) 0xc,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x8c,(byte) 0x4c,(byte) 0x38, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(6,10,0,-7,7,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xfc,(byte) 0x44,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0xc,(byte) 0x8c,(byte) 0x4c,(byte) 0x38, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(6,10,0,-7,7,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(12,15,-1,0,14,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(7,7,-1,-10,9,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc,(byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,2,-1,-14,8,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x60,(byte) 0x3,(byte) 0x0,(byte) 0x47,(byte) 0x19,(byte) 0x0,(byte) 0xc2, +(byte) 0x31,(byte) 0x80,(byte) 0x82,(byte) 0x20,(byte) 0x80,(byte) 0x82,(byte) 0x40,(byte) 0x80,(byte) 0x83,(byte) 0xe0,(byte) 0x80,(byte) 0x82,(byte) 0x30,(byte) 0x80,(byte) 0x82,(byte) 0x10, +(byte) 0x80,(byte) 0xc2,(byte) 0x11,(byte) 0x80,(byte) 0x42,(byte) 0x31,(byte) 0x0,(byte) 0x67,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0xf0,(byte) 0x0, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(17,17,-1,0,19,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(7,2,-1,-5,9,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(12,7,-1,-3,14,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x8,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x19,(byte) 0x80,(byte) 0x8,(byte) 0x80, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(9,10,-2,-1,13,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0x7e,(byte) 0x0,(byte) 0x76,(byte) 0xcc,(byte) 0xcc,(byte) 0x7c,(byte) 0xc,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(7,9,0,-8,8,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x61,(byte) 0xc3,(byte) 0x0,(byte) 0x47,(byte) 0x71,(byte) 0x0,(byte) 0xc4, +(byte) 0x19,(byte) 0x80,(byte) 0x8c,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x8c,(byte) 0x0, +(byte) 0x80,(byte) 0xc4,(byte) 0x19,(byte) 0x80,(byte) 0x47,(byte) 0x31,(byte) 0x0,(byte) 0x61,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0xf0,(byte) 0x0, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(17,17,-1,0,19,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(6,2,-1,-14,8,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x38,(byte) 0x64,(byte) 0x62,(byte) 0x6,(byte) 0xe,(byte) 0x1c,(byte) 0x38,(byte) 0x74,(byte) 0xe2,(byte) 0xc3,(byte) 0x83,(byte) 0x87,(byte) 0x4e,(byte) 0x3c,(byte) 0x38,(byte) 0x70, +(byte) 0x60,(byte) 0x46,(byte) 0x26,(byte) 0x1c, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(8,20,-2,2,12,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-2,0,6,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0, +(byte) 0x3,(byte) 0x0,(byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x60,(byte) 0x30,(byte) 0x20,(byte) 0x70,(byte) 0x30, +(byte) 0xf8,(byte) 0x7c, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(14,17,0,0,14,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xee,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x31,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0xee,(byte) 0xe0,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(11,12,-1,-3,13,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xe7,(byte) 0x80,(byte) 0xbe,(byte) 0xc0,(byte) 0x78,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(10,17,-1,0,12,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xd0,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xc8,(byte) 0x0, +(byte) 0xc8,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x43,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x0, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(9,16,-1,2,12,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(2,17,-4,5,8,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,6,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x83,(byte) 0x80,(byte) 0xc7,(byte) 0xc0,(byte) 0x7c,(byte) 0x60,(byte) 0x38,(byte) 0x20, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(11,4,-1,-5,13,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0x4,(byte) 0x3,(byte) 0x4,(byte) 0xc,(byte) 0x8,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(8,22,-1,5,10,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(2,17,-2,0,6,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x7,(byte) 0xc,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0x7, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(8,22,-1,5,10,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xff,(byte) 0xc3,(byte) 0x61,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0xe,(byte) 0x86,(byte) 0xc3,(byte) 0xff, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(8,12,-1,0,10,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(11,17,0,5,11,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x21,(byte) 0x80,(byte) 0x33,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1a,(byte) 0x0, +(byte) 0x39,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(11,12,-1,0,13,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x4,(byte) 0x10,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0x1a,(byte) 0x28,(byte) 0x0,(byte) 0x1a,(byte) 0x64,(byte) 0x0,(byte) 0x19, +(byte) 0x64,(byte) 0x0,(byte) 0x31,(byte) 0x64,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc3, +(byte) 0x0,(byte) 0xf1,(byte) 0xe7,(byte) 0x80, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(17,12,0,0,17,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80, +(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(11,12,0,0,11,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(11,12,-1,0,13,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x1c,(byte) 0x32,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x70,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(7,15,0,0,7,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0xf8,(byte) 0xc6,(byte) 0x83,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x7c,(byte) 0x70,(byte) 0xe0,(byte) 0xc2,(byte) 0x66,(byte) 0x3e, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(8,12,-1,0,10,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x76,(byte) 0x6e,(byte) 0xe6, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(7,12,-1,0,8,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0x1d,(byte) 0x80, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(10,17,-1,5,12,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0xee,(byte) 0x0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(10,17,-1,5,12,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(10,12,-1,0,12,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(11,12,-1,0,13,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xf1,(byte) 0xe3,(byte) 0xc0,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60, +(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x71,(byte) 0xe3,(byte) 0x80,(byte) 0x6f,(byte) 0x9f, +(byte) 0x0,(byte) 0xe7,(byte) 0xe,(byte) 0x0, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(18,12,-1,0,20,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60, +(byte) 0xe0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(4,17,-1,0,6,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0xf3,(byte) 0xe0,(byte) 0x61,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x68,(byte) 0x0, +(byte) 0x64,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(11,17,-1,0,12,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0xc0,(byte) 0xe0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(4,22,0,5,6,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x60, +(byte) 0x60, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(4,17,-1,0,6,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(11,17,-1,0,13,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x3f,(byte) 0x0,(byte) 0xf1,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x3f,(byte) 0xc0,(byte) 0x7f,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1f,(byte) 0xc0, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(11,17,-1,5,12,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x16, +(byte) 0xe, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(7,17,0,0,7,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(9,12,-1,0,11,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x1e,(byte) 0xc0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80, +(byte) 0x3,(byte) 0x80, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(10,17,-1,0,12,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(9,12,-1,0,11,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0x5e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(10,17,-1,0,12,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(9,12,-1,0,11,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x60,(byte) 0xe0,(byte) 0x80,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(3,5,-2,-12,7,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff,(byte) 0xf8,(byte) 0xff,(byte) 0xf8, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(13,2,0,5,13,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x80,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x14,(byte) 0x0,(byte) 0x1c,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(9,9,-1,-8,11,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf8,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(5,21,-1,4,8,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x6,(byte) 0x6,(byte) 0x4,(byte) 0xc,(byte) 0xc,(byte) 0x8,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,17,0,0,7,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf8,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xf8, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(5,21,-2,4,8,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xff,(byte) 0xf8,(byte) 0xe0,(byte) 0x18,(byte) 0x70,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0xc0,(byte) 0x80,(byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0x70, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(13,17,-1,0,15,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0, +(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc, +(byte) 0xfc,(byte) 0x3f, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(16,17,0,0,16,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xfc,(byte) 0xf,(byte) 0xc0,(byte) 0x30,(byte) 0x3,(byte) 0x80,(byte) 0x18,(byte) 0x7,(byte) 0x0,(byte) 0x8,(byte) 0xe,(byte) 0x0,(byte) 0x4,(byte) 0xc,(byte) 0x0,(byte) 0x6, +(byte) 0x18,(byte) 0x0,(byte) 0x2,(byte) 0x38,(byte) 0x0,(byte) 0x1,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0, +(byte) 0x0,(byte) 0x3,(byte) 0xa0,(byte) 0x0,(byte) 0x3,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x8,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x1c,(byte) 0x6,(byte) 0x0, +(byte) 0x7e,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(18,17,0,0,18,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x80,(byte) 0x3,(byte) 0x87,(byte) 0x80,(byte) 0x3,(byte) 0x46,(byte) 0x80,(byte) 0x3, +(byte) 0x46,(byte) 0xc0,(byte) 0x6,(byte) 0x46,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x60,(byte) 0xc,(byte) 0x2c,(byte) 0x60,(byte) 0xc,(byte) 0x2c, +(byte) 0x20,(byte) 0x18,(byte) 0x2c,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x18, +(byte) 0xfc,(byte) 0x7e,(byte) 0x7e, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(23,17,0,0,23,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x40,(byte) 0x0,(byte) 0x3, +(byte) 0x60,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0xc,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x18, +(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x30,(byte) 0x4,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0, +(byte) 0xfc,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(17,17,0,0,17,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(16,17,-1,0,18,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x83,(byte) 0x4,(byte) 0x83,(byte) 0x4,(byte) 0xc3,(byte) 0xc, +(byte) 0xff,(byte) 0xfc, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(14,17,-1,0,16,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x9e,(byte) 0x0,(byte) 0xf1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0, +(byte) 0xf,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0xc0, +(byte) 0x1e,(byte) 0x40, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(11,17,-1,0,13,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xfc,(byte) 0x1e,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xc0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(15,17,-1,0,16,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xe0,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c, +(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe0, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(16,22,-1,5,18,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(13,17,-1,0,15,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(16,17,-1,0,18,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84, +(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xf0,(byte) 0x1f, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(16,17,-1,0,18,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xf8,(byte) 0x21,(byte) 0xf8,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x21, +(byte) 0x88,(byte) 0x60,(byte) 0x21,(byte) 0x88,(byte) 0x60,(byte) 0x23,(byte) 0x8,(byte) 0x60,(byte) 0x23,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x2, +(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x30,(byte) 0x0,(byte) 0xe0, +(byte) 0xf0,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(21,17,-1,0,22,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0xfc,(byte) 0x0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(13,17,-1,0,14,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x30,(byte) 0xe,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0xe0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80, +(byte) 0x3f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18, +(byte) 0xfc,(byte) 0x7e, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(16,17,-1,0,17,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x78,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(9,17,-1,0,11,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(6,17,-1,0,8,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30, +(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x3f,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6, +(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0, +(byte) 0xfc,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(17,17,-1,0,19,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0xc,(byte) 0x60,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0x3f, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c, +(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(16,17,-1,0,18,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20, +(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(12,17,-1,0,14,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(13,17,-1,0,15,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xff,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6, +(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(15,17,-1,0,17,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c, +(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(14,17,-1,0,16,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xff,(byte) 0xe0,(byte) 0x30,(byte) 0x78,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38, +(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(14,17,-1,0,16,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(17,17,0,0,17,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3,(byte) 0xf0,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x61,(byte) 0xde,(byte) 0x0,(byte) 0x63, +(byte) 0x7b,(byte) 0x0,(byte) 0xc6,(byte) 0x39,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0xc0,(byte) 0xc6,(byte) 0x18,(byte) 0x40,(byte) 0xc6,(byte) 0xc, +(byte) 0x40,(byte) 0xc3,(byte) 0xc,(byte) 0x40,(byte) 0xc3,(byte) 0x8c,(byte) 0x40,(byte) 0xe1,(byte) 0xfc,(byte) 0x40,(byte) 0x60,(byte) 0xec,(byte) 0xc0,(byte) 0x70,(byte) 0x0,(byte) 0x80, +(byte) 0x38,(byte) 0x1,(byte) 0x80,(byte) 0x1c,(byte) 0x3,(byte) 0x0,(byte) 0xf,(byte) 0xe,(byte) 0x0,(byte) 0x3,(byte) 0xf8,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(18,20,-2,3,22,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xe,(byte) 0x7,(byte) 0xc3,(byte) 0xc3,(byte) 0x83,(byte) 0xc6, +(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(8,17,-2,0,11,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0, +(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(11,11,-1,-1,13,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(12,6,-1,-4,14,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(11,11,-1,-1,13,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(3,14,-2,3,7,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,11,-2,0,6,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0xc0, +(byte) 0x61,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x77,(byte) 0x80, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(10,17,-1,0,12,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0xe1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x41,(byte) 0xc0,(byte) 0x61,(byte) 0x80, +(byte) 0x37,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(10,17,-1,0,12,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x2,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, +(byte) 0x7f,(byte) 0xc0, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(10,17,-1,0,12,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7b,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc1,(byte) 0x80,(byte) 0xf3,(byte) 0x80,(byte) 0xee,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x3,(byte) 0xc0, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(10,17,-1,0,12,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7e,(byte) 0x0,(byte) 0xe3,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x1,(byte) 0xc0, +(byte) 0x3,(byte) 0x80,(byte) 0xf,(byte) 0x80,(byte) 0x7e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x1f,(byte) 0x80, +(byte) 0x1f,(byte) 0xc0, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(10,17,-1,0,12,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc3,(byte) 0x0,(byte) 0x43,(byte) 0x0, +(byte) 0x63,(byte) 0x0,(byte) 0x23,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(10,17,-1,0,12,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x78,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0x80, +(byte) 0x7,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x47,(byte) 0x0,(byte) 0x7e,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(9,17,-1,0,12,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0x60,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x43,(byte) 0x80,(byte) 0x7f,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(10,17,-1,0,12,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x78,(byte) 0x18, +(byte) 0x8, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(8,17,-2,0,12,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(10,17,-1,0,12,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0xc,(byte) 0x4,(byte) 0x6, +(byte) 0x6,(byte) 0x3,(byte) 0x3,(byte) 0x3, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(8,20,1,3,7,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-2,0,6,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(12,2,-1,-6,14,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(3,5,-2,3,7,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(12,12,-1,-1,14,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x8,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0xeb,(byte) 0x80,(byte) 0x1c,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x1c,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(9,9,-2,-8,12,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0x18, +(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(6,22,-1,5,8,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60, +(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(6,22,-1,5,8,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(3,5,-3,-12,8,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x3c,(byte) 0x3c,(byte) 0x7f,(byte) 0x7e,(byte) 0xe1,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc1,(byte) 0xa0,(byte) 0x63,(byte) 0x20,(byte) 0x37,(byte) 0x10, +(byte) 0x1e,(byte) 0x18,(byte) 0xe,(byte) 0x3e,(byte) 0xf,(byte) 0x0,(byte) 0x1d,(byte) 0x80,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x40,(byte) 0xc,(byte) 0xc0, +(byte) 0x7,(byte) 0x80, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(16,17,-1,0,18,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x30,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x72,(byte) 0x0,(byte) 0xc,(byte) 0x61,(byte) 0x0,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60,(byte) 0x80,(byte) 0x3, +(byte) 0x30,(byte) 0x80,(byte) 0x1,(byte) 0x19,(byte) 0x80,(byte) 0x1,(byte) 0x8f,(byte) 0x0,(byte) 0x78,(byte) 0xc0,(byte) 0x0,(byte) 0xe4,(byte) 0x40,(byte) 0x0,(byte) 0xc2,(byte) 0x60, +(byte) 0x0,(byte) 0xc1,(byte) 0x30,(byte) 0x0,(byte) 0xc1,(byte) 0x10,(byte) 0x0,(byte) 0x61,(byte) 0x18,(byte) 0x0,(byte) 0x33,(byte) 0xfc,(byte) 0x0,(byte) 0x1e,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(17,16,-1,0,19,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3f,(byte) 0x0,(byte) 0xe5,(byte) 0xc0,(byte) 0xc4,(byte) 0xc0,(byte) 0x84,(byte) 0x60,(byte) 0x84,(byte) 0x60,(byte) 0x4,(byte) 0x60, +(byte) 0x4,(byte) 0xe0,(byte) 0x7,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x74,(byte) 0x0,(byte) 0x64,(byte) 0x0,(byte) 0x64,(byte) 0x20, +(byte) 0x64,(byte) 0x60,(byte) 0x34,(byte) 0xe0,(byte) 0x1f,(byte) 0x80,(byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(11,21,0,2,12,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0x11,(byte) 0x0, +(byte) 0x11,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x7f,(byte) 0xe0,(byte) 0x7f,(byte) 0xe0,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80, +(byte) 0x8,(byte) 0x80, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(11,17,-1,0,13,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x88,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(6,5,-1,-12,10,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(2,17,-3,0,8,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,6,zerodata); + + static final BitmapCharRec chars[] = { + 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + ch160, + ch161, + ch162, + ch163, + ch164, + ch165, + ch166, + ch167, + ch168, + ch169, + ch170, + ch171, + ch172, + ch173, + ch174, + ch175, + ch176, + ch177, + ch178, + ch179, + ch180, + ch181, + ch182, + ch183, + ch184, + ch185, + ch186, + ch187, + ch188, + ch189, + ch190, + ch191, + ch192, + ch193, + ch194, + ch195, + ch196, + ch197, + ch198, + ch199, + ch200, + ch201, + ch202, + ch203, + ch204, + ch205, + ch206, + ch207, + ch208, + ch209, + ch210, + ch211, + ch212, + ch213, + ch214, + ch215, + ch216, + ch217, + ch218, + ch219, + ch220, + ch221, + ch222, + ch223, + ch224, + ch225, + ch226, + ch227, + ch228, + ch229, + ch230, + ch231, + ch232, + ch233, + ch234, + ch235, + ch236, + ch237, + ch238, + ch239, + ch240, + ch241, + ch242, + ch243, + ch244, + ch245, + ch246, + ch247, + ch248, + ch249, + ch250, + ch251, + ch252, + ch253, + ch254, + ch255, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-times-medium-r-*--24-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapTimesRoman24 diff --git a/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java b/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java new file mode 100644 index 0000000..3f8b511 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java @@ -0,0 +1,2458 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + +public class glutStrokeMonoRoman implements GLUTStrokeFont { +/* char: 33 '!' */ + +static final CoordRec[] char33_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 33.3333 ), +}; + +static final CoordRec[] char33_stroke1 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char33[] = { + new StrokeRec(2, char33_stroke0), + new StrokeRec(5, char33_stroke1), +}; + +/* char: 34 '"' */ + +static final CoordRec[] char34_stroke0 = { + new CoordRec( (float) 33.3334, (float) 100 ), + new CoordRec( (float) 33.3334, (float) 66.6667 ), +}; + +static final CoordRec[] char34_stroke1 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 71.4286, (float) 66.6667 ), +}; + +static final StrokeRec char34[] = { + new StrokeRec(2, char34_stroke0), + new StrokeRec(2, char34_stroke1), +}; + +/* char: 35 '#' */ + +static final CoordRec[] char35_stroke0 = { + new CoordRec( (float) 54.7619, (float) 119.048 ), + new CoordRec( (float) 21.4286, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke1 = { + new CoordRec( (float) 83.3334, (float) 119.048 ), + new CoordRec( (float) 50, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke2 = { + new CoordRec( (float) 21.4286, (float) 57.1429 ), + new CoordRec( (float) 88.0952, (float) 57.1429 ), +}; + +static final CoordRec[] char35_stroke3 = { + new CoordRec( (float) 16.6667, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), +}; + +static final StrokeRec char35[] = { + new StrokeRec(2, char35_stroke0), + new StrokeRec(2, char35_stroke1), + new StrokeRec(2, char35_stroke2), + new StrokeRec(2, char35_stroke3), +}; + +/* char: 36 '$' */ + +static final CoordRec[] char36_stroke0 = { + new CoordRec( (float) 42.8571, (float) 119.048 ), + new CoordRec( (float) 42.8571, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke1 = { + new CoordRec( (float) 61.9047, (float) 119.048 ), + new CoordRec( (float) 61.9047, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke2 = { + new CoordRec( (float) 85.7143, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 19.0476, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 19.0476, (float) 14.2857 ), +}; + +static final StrokeRec char36[] = { + new StrokeRec(2, char36_stroke0), + new StrokeRec(2, char36_stroke1), + new StrokeRec(20, char36_stroke2), +}; + +/* char: 37 '%' */ + +static final CoordRec[] char37_stroke0 = { + new CoordRec( (float) 95.2381, (float) 100 ), + new CoordRec( (float) 9.5238, (float) 0 ), +}; + +static final CoordRec[] char37_stroke1 = { + new CoordRec( (float) 33.3333, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 90.4762 ), + new CoordRec( (float) 42.8571, (float) 80.9524 ), + new CoordRec( (float) 38.0952, (float) 71.4286 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 19.0476, (float) 66.6667 ), + new CoordRec( (float) 9.5238, (float) 76.1905 ), + new CoordRec( (float) 9.5238, (float) 85.7143 ), + new CoordRec( (float) 14.2857, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 95.2381 ), + new CoordRec( (float) 57.1428, (float) 90.4762 ), + new CoordRec( (float) 71.4286, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 95.2381 ), + new CoordRec( (float) 95.2381, (float) 100 ), +}; + +static final CoordRec[] char37_stroke2 = { + new CoordRec( (float) 76.1905, (float) 33.3333 ), + new CoordRec( (float) 66.6667, (float) 28.5714 ), + new CoordRec( (float) 61.9048, (float) 19.0476 ), + new CoordRec( (float) 61.9048, (float) 9.5238 ), + new CoordRec( (float) 71.4286, (float) 0 ), + new CoordRec( (float) 80.9524, (float) 0 ), + new CoordRec( (float) 90.4762, (float) 4.7619 ), + new CoordRec( (float) 95.2381, (float) 14.2857 ), + new CoordRec( (float) 95.2381, (float) 23.8095 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 76.1905, (float) 33.3333 ), +}; + +static final StrokeRec char37[] = { + new StrokeRec(2, char37_stroke0), + new StrokeRec(16, char37_stroke1), + new StrokeRec(11, char37_stroke2), +}; + +/* char: 38 '&' */ + +static final CoordRec[] char38_stroke0 = { + new CoordRec( (float) 100, (float) 57.1429 ), + new CoordRec( (float) 100, (float) 61.9048 ), + new CoordRec( (float) 95.2381, (float) 66.6667 ), + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 85.7143, (float) 61.9048 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4286, (float) 28.5714 ), + new CoordRec( (float) 61.9048, (float) 14.2857 ), + new CoordRec( (float) 52.3809, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 23.8095, (float) 0 ), + new CoordRec( (float) 14.2857, (float) 4.7619 ), + new CoordRec( (float) 9.5238, (float) 9.5238 ), + new CoordRec( (float) 4.7619, (float) 19.0476 ), + new CoordRec( (float) 4.7619, (float) 28.5714 ), + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), + new CoordRec( (float) 47.619, (float) 61.9048 ), + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 57.1429, (float) 76.1905 ), + new CoordRec( (float) 57.1429, (float) 85.7143 ), + new CoordRec( (float) 52.3809, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 28.5714, (float) 85.7143 ), + new CoordRec( (float) 28.5714, (float) 76.1905 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 47.619 ), + new CoordRec( (float) 66.6667, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 85.7143, (float) 0 ), + new CoordRec( (float) 95.2381, (float) 0 ), + new CoordRec( (float) 100, (float) 4.7619 ), + new CoordRec( (float) 100, (float) 9.5238 ), +}; + +static final StrokeRec char38[] = { + new StrokeRec(34, char38_stroke0), +}; + +/* char: 39 ''' */ + +static final CoordRec[] char39_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final StrokeRec char39[] = { + new StrokeRec(2, char39_stroke0), +}; + +/* char: 40 '(' */ + +static final CoordRec[] char40_stroke0 = { + new CoordRec( (float) 69.0476, (float) 119.048 ), + new CoordRec( (float) 59.5238, (float) 109.524 ), + new CoordRec( (float) 50, (float) 95.2381 ), + new CoordRec( (float) 40.4762, (float) 76.1905 ), + new CoordRec( (float) 35.7143, (float) 52.381 ), + new CoordRec( (float) 35.7143, (float) 33.3333 ), + new CoordRec( (float) 40.4762, (float) 9.5238 ), + new CoordRec( (float) 50, (float) -9.5238 ), + new CoordRec( (float) 59.5238, (float) -23.8095 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char40[] = { + new StrokeRec(10, char40_stroke0), +}; + +/* char: 41 ')' */ + +static final CoordRec[] char41_stroke0 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 45.2381, (float) 109.524 ), + new CoordRec( (float) 54.7619, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 76.1905 ), + new CoordRec( (float) 69.0476, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 9.5238 ), + new CoordRec( (float) 54.7619, (float) -9.5238 ), + new CoordRec( (float) 45.2381, (float) -23.8095 ), + new CoordRec( (float) 35.7143, (float) -33.3333 ), +}; + +static final StrokeRec char41[] = { + new StrokeRec(10, char41_stroke0), +}; + +/* char: 42 '*' */ + +static final CoordRec[] char42_stroke0 = { + new CoordRec( (float) 52.381, (float) 71.4286 ), + new CoordRec( (float) 52.381, (float) 14.2857 ), +}; + +static final CoordRec[] char42_stroke1 = { + new CoordRec( (float) 28.5715, (float) 57.1429 ), + new CoordRec( (float) 76.1905, (float) 28.5714 ), +}; + +static final CoordRec[] char42_stroke2 = { + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 28.5715, (float) 28.5714 ), +}; + +static final StrokeRec char42[] = { + new StrokeRec(2, char42_stroke0), + new StrokeRec(2, char42_stroke1), + new StrokeRec(2, char42_stroke2), +}; + +/* char: 43 '+' */ + +static final CoordRec[] char43_stroke0 = { + new CoordRec( (float) 52.3809, (float) 85.7143 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char43_stroke1 = { + new CoordRec( (float) 9.5238, (float) 42.8571 ), + new CoordRec( (float) 95.2381, (float) 42.8571 ), +}; + +static final StrokeRec char43[] = { + new StrokeRec(2, char43_stroke0), + new StrokeRec(2, char43_stroke1), +}; + +/* char: 44 ',' */ + +static final CoordRec[] char44_stroke0 = { + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) -4.7619 ), + new CoordRec( (float) 52.381, (float) -14.2857 ), + new CoordRec( (float) 47.6191, (float) -19.0476 ), +}; + +static final StrokeRec char44[] = { + new StrokeRec(8, char44_stroke0), +}; + +/* char: 45 '-' */ + +static final CoordRec[] char45_stroke0 = { + new CoordRec( (float) 9.5238, (float) 42.8571 ), + new CoordRec( (float) 95.2381, (float) 42.8571 ), +}; + +static final StrokeRec char45[] = { + new StrokeRec(2, char45_stroke0), +}; + +/* char: 46 '.' */ + +static final CoordRec[] char46_stroke0 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char46[] = { + new StrokeRec(5, char46_stroke0), +}; + +/* char: 47 '/' */ + +static final CoordRec[] char47_stroke0 = { + new CoordRec( (float) 19.0476, (float) -14.2857 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char47[] = { + new StrokeRec(2, char47_stroke0), +}; + +/* char: 48 '0' */ + +static final CoordRec[] char48_stroke0 = { + new CoordRec( (float) 47.619, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 19.0476, (float) 57.1429 ), + new CoordRec( (float) 19.0476, (float) 42.8571 ), + new CoordRec( (float) 23.8095, (float) 19.0476 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 19.0476 ), + new CoordRec( (float) 85.7143, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 57.1429 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 57.1428, (float) 100 ), + new CoordRec( (float) 47.619, (float) 100 ), +}; + +static final StrokeRec char48[] = { + new StrokeRec(17, char48_stroke0), +}; + +/* char: 49 '1' */ + +static final CoordRec[] char49_stroke0 = { + new CoordRec( (float) 40.4762, (float) 80.9524 ), + new CoordRec( (float) 50, (float) 85.7143 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 64.2857, (float) 0 ), +}; + +static final StrokeRec char49[] = { + new StrokeRec(4, char49_stroke0), +}; + +/* char: 50 '2' */ + +static final CoordRec[] char50_stroke0 = { + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 28.5714, (float) 90.4762 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 90.4762 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 80.9524, (float) 71.4286 ), + new CoordRec( (float) 76.1905, (float) 61.9048 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 19.0476, (float) 0 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char50[] = { + new StrokeRec(14, char50_stroke0), +}; + +/* char: 51 '3' */ + +static final CoordRec[] char51_stroke0 = { + new CoordRec( (float) 28.5714, (float) 100 ), + new CoordRec( (float) 80.9524, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 61.9048 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), +}; + +static final StrokeRec char51[] = { + new StrokeRec(15, char51_stroke0), +}; + +/* char: 52 '4' */ + +static final CoordRec[] char52_stroke0 = { + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 16.6667, (float) 33.3333 ), + new CoordRec( (float) 88.0952, (float) 33.3333 ), +}; + +static final CoordRec[] char52_stroke1 = { + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 64.2857, (float) 0 ), +}; + +static final StrokeRec char52[] = { + new StrokeRec(3, char52_stroke0), + new StrokeRec(2, char52_stroke1), +}; + +/* char: 53 '5' */ + +static final CoordRec[] char53_stroke0 = { + new CoordRec( (float) 76.1905, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 57.1429 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 61.9048 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), +}; + +static final StrokeRec char53[] = { + new StrokeRec(17, char53_stroke0), +}; + +/* char: 54 '6' */ + +static final CoordRec[] char54_stroke0 = { + new CoordRec( (float) 78.5714, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 59.5238, (float) 100 ), + new CoordRec( (float) 50, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 80.9524 ), + new CoordRec( (float) 21.4286, (float) 57.1429 ), + new CoordRec( (float) 21.4286, (float) 33.3333 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 50, (float) 0 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 78.5714, (float) 14.2857 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 33.3333 ), + new CoordRec( (float) 78.5714, (float) 47.619 ), + new CoordRec( (float) 69.0476, (float) 57.1429 ), + new CoordRec( (float) 54.7619, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 61.9048 ), + new CoordRec( (float) 35.7143, (float) 57.1429 ), + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 21.4286, (float) 33.3333 ), +}; + +static final StrokeRec char54[] = { + new StrokeRec(23, char54_stroke0), +}; + +/* char: 55 '7' */ + +static final CoordRec[] char55_stroke0 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 38.0952, (float) 0 ), +}; + +static final CoordRec[] char55_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char55[] = { + new StrokeRec(2, char55_stroke0), + new StrokeRec(2, char55_stroke1), +}; + +/* char: 56 '8' */ + +static final CoordRec[] char56_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 57.1428, (float) 57.1429 ), + new CoordRec( (float) 71.4286, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 85.7143, (float) 19.0476 ), + new CoordRec( (float) 80.9524, (float) 9.5238 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), + new CoordRec( (float) 19.0476, (float) 33.3333 ), + new CoordRec( (float) 23.8095, (float) 42.8571 ), + new CoordRec( (float) 33.3333, (float) 52.381 ), + new CoordRec( (float) 47.619, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final StrokeRec char56[] = { + new StrokeRec(29, char56_stroke0), +}; + +/* char: 57 '9' */ + +static final CoordRec[] char57_stroke0 = { + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 78.5714, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 42.8571 ), + new CoordRec( (float) 54.7619, (float) 38.0952 ), + new CoordRec( (float) 50, (float) 38.0952 ), + new CoordRec( (float) 35.7143, (float) 42.8571 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 21.4286, (float) 66.6667 ), + new CoordRec( (float) 21.4286, (float) 71.4286 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 50, (float) 100 ), + new CoordRec( (float) 54.7619, (float) 100 ), + new CoordRec( (float) 69.0476, (float) 95.2381 ), + new CoordRec( (float) 78.5714, (float) 85.7143 ), + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 83.3334, (float) 42.8571 ), + new CoordRec( (float) 78.5714, (float) 19.0476 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), +}; + +static final StrokeRec char57[] = { + new StrokeRec(23, char57_stroke0), +}; + +/* char: 58 ':' */ + +static final CoordRec[] char58_stroke0 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 57.1429 ), + new CoordRec( (float) 57.1429, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final CoordRec[] char58_stroke1 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char58[] = { + new StrokeRec(5, char58_stroke0), + new StrokeRec(5, char58_stroke1), +}; + +/* char: 59 ';' */ + +static final CoordRec[] char59_stroke0 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 57.1429 ), + new CoordRec( (float) 57.1429, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final CoordRec[] char59_stroke1 = { + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) -4.7619 ), + new CoordRec( (float) 52.381, (float) -14.2857 ), + new CoordRec( (float) 47.6191, (float) -19.0476 ), +}; + +static final StrokeRec char59[] = { + new StrokeRec(5, char59_stroke0), + new StrokeRec(8, char59_stroke1), +}; + +/* char: 60 '<' */ + +static final CoordRec[] char60_stroke0 = { + new CoordRec( (float) 90.4762, (float) 85.7143 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final StrokeRec char60[] = { + new StrokeRec(3, char60_stroke0), +}; + +/* char: 61 '=' */ + +static final CoordRec[] char61_stroke0 = { + new CoordRec( (float) 9.5238, (float) 57.1429 ), + new CoordRec( (float) 95.2381, (float) 57.1429 ), +}; + +static final CoordRec[] char61_stroke1 = { + new CoordRec( (float) 9.5238, (float) 28.5714 ), + new CoordRec( (float) 95.2381, (float) 28.5714 ), +}; + +static final StrokeRec char61[] = { + new StrokeRec(2, char61_stroke0), + new StrokeRec(2, char61_stroke1), +}; + +/* char: 62 '>' */ + +static final CoordRec[] char62_stroke0 = { + new CoordRec( (float) 14.2857, (float) 85.7143 ), + new CoordRec( (float) 90.4762, (float) 42.8571 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final StrokeRec char62[] = { + new StrokeRec(3, char62_stroke0), +}; + +/* char: 63 '?' */ + +static final CoordRec[] char63_stroke0 = { + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 28.5714, (float) 90.4762 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 71.4285, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 90.4762 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 80.9524, (float) 71.4286 ), + new CoordRec( (float) 76.1905, (float) 61.9048 ), + new CoordRec( (float) 71.4285, (float) 57.1429 ), + new CoordRec( (float) 52.3809, (float) 47.619 ), + new CoordRec( (float) 52.3809, (float) 33.3333 ), +}; + +static final CoordRec[] char63_stroke1 = { + new CoordRec( (float) 52.3809, (float) 9.5238 ), + new CoordRec( (float) 47.619, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 9.5238 ), +}; + +static final StrokeRec char63[] = { + new StrokeRec(14, char63_stroke0), + new StrokeRec(5, char63_stroke1), +}; + +/* char: 64 '@' */ + +static final CoordRec[] char64_stroke0 = { + new CoordRec( (float) 64.2857, (float) 52.381 ), + new CoordRec( (float) 54.7619, (float) 57.1429 ), + new CoordRec( (float) 45.2381, (float) 57.1429 ), + new CoordRec( (float) 40.4762, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 42.8571 ), + new CoordRec( (float) 45.2381, (float) 33.3333 ), + new CoordRec( (float) 54.7619, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 38.0952 ), +}; + +static final CoordRec[] char64_stroke1 = { + new CoordRec( (float) 64.2857, (float) 57.1429 ), + new CoordRec( (float) 64.2857, (float) 38.0952 ), + new CoordRec( (float) 69.0476, (float) 33.3333 ), + new CoordRec( (float) 78.5714, (float) 33.3333 ), + new CoordRec( (float) 83.3334, (float) 42.8571 ), + new CoordRec( (float) 83.3334, (float) 47.619 ), + new CoordRec( (float) 78.5714, (float) 61.9048 ), + new CoordRec( (float) 69.0476, (float) 71.4286 ), + new CoordRec( (float) 54.7619, (float) 76.1905 ), + new CoordRec( (float) 50, (float) 76.1905 ), + new CoordRec( (float) 35.7143, (float) 71.4286 ), + new CoordRec( (float) 26.1905, (float) 61.9048 ), + new CoordRec( (float) 21.4286, (float) 47.619 ), + new CoordRec( (float) 21.4286, (float) 42.8571 ), + new CoordRec( (float) 26.1905, (float) 28.5714 ), + new CoordRec( (float) 35.7143, (float) 19.0476 ), + new CoordRec( (float) 50, (float) 14.2857 ), + new CoordRec( (float) 54.7619, (float) 14.2857 ), + new CoordRec( (float) 69.0476, (float) 19.0476 ), +}; + +static final StrokeRec char64[] = { + new StrokeRec(8, char64_stroke0), + new StrokeRec(19, char64_stroke1), +}; + +/* char: 65 'A' */ + +static final CoordRec[] char65_stroke0 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final CoordRec[] char65_stroke1 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final CoordRec[] char65_stroke2 = { + new CoordRec( (float) 28.5714, (float) 33.3333 ), + new CoordRec( (float) 76.1905, (float) 33.3333 ), +}; + +static final StrokeRec char65[] = { + new StrokeRec(2, char65_stroke0), + new StrokeRec(2, char65_stroke1), + new StrokeRec(2, char65_stroke2), +}; + +/* char: 66 'B' */ + +static final CoordRec[] char66_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char66_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 71.4286 ), + new CoordRec( (float) 80.9524, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), +}; + +static final CoordRec[] char66_stroke2 = { + new CoordRec( (float) 19.0476, (float) 52.381 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), + new CoordRec( (float) 76.1905, (float) 47.619 ), + new CoordRec( (float) 80.9524, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 85.7143, (float) 19.0476 ), + new CoordRec( (float) 80.9524, (float) 9.5238 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char66[] = { + new StrokeRec(2, char66_stroke0), + new StrokeRec(9, char66_stroke1), + new StrokeRec(10, char66_stroke2), +}; + +/* char: 67 'C' */ + +static final CoordRec[] char67_stroke0 = { + new CoordRec( (float) 88.0952, (float) 76.1905 ), + new CoordRec( (float) 83.3334, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 21.4286, (float) 76.1905 ), + new CoordRec( (float) 16.6667, (float) 61.9048 ), + new CoordRec( (float) 16.6667, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 23.8095 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 0 ), + new CoordRec( (float) 73.8096, (float) 4.7619 ), + new CoordRec( (float) 83.3334, (float) 14.2857 ), + new CoordRec( (float) 88.0952, (float) 23.8095 ), +}; + +static final StrokeRec char67[] = { + new StrokeRec(18, char67_stroke0), +}; + +/* char: 68 'D' */ + +static final CoordRec[] char68_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char68_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 66.6666, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 85.7143 ), + new CoordRec( (float) 80.9524, (float) 76.1905 ), + new CoordRec( (float) 85.7143, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 23.8095 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 0 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char68[] = { + new StrokeRec(2, char68_stroke0), + new StrokeRec(12, char68_stroke1), +}; + +/* char: 69 'E' */ + +static final CoordRec[] char69_stroke0 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 21.4286, (float) 0 ), +}; + +static final CoordRec[] char69_stroke1 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 83.3334, (float) 100 ), +}; + +static final CoordRec[] char69_stroke2 = { + new CoordRec( (float) 21.4286, (float) 52.381 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), +}; + +static final CoordRec[] char69_stroke3 = { + new CoordRec( (float) 21.4286, (float) 0 ), + new CoordRec( (float) 83.3334, (float) 0 ), +}; + +static final StrokeRec char69[] = { + new StrokeRec(2, char69_stroke0), + new StrokeRec(2, char69_stroke1), + new StrokeRec(2, char69_stroke2), + new StrokeRec(2, char69_stroke3), +}; + +/* char: 70 'F' */ + +static final CoordRec[] char70_stroke0 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 21.4286, (float) 0 ), +}; + +static final CoordRec[] char70_stroke1 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 83.3334, (float) 100 ), +}; + +static final CoordRec[] char70_stroke2 = { + new CoordRec( (float) 21.4286, (float) 52.381 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), +}; + +static final StrokeRec char70[] = { + new StrokeRec(2, char70_stroke0), + new StrokeRec(2, char70_stroke1), + new StrokeRec(2, char70_stroke2), +}; + +/* char: 71 'G' */ + +static final CoordRec[] char71_stroke0 = { + new CoordRec( (float) 88.0952, (float) 76.1905 ), + new CoordRec( (float) 83.3334, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 21.4286, (float) 76.1905 ), + new CoordRec( (float) 16.6667, (float) 61.9048 ), + new CoordRec( (float) 16.6667, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 23.8095 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 0 ), + new CoordRec( (float) 73.8096, (float) 4.7619 ), + new CoordRec( (float) 83.3334, (float) 14.2857 ), + new CoordRec( (float) 88.0952, (float) 23.8095 ), + new CoordRec( (float) 88.0952, (float) 38.0952 ), +}; + +static final CoordRec[] char71_stroke1 = { + new CoordRec( (float) 64.2857, (float) 38.0952 ), + new CoordRec( (float) 88.0952, (float) 38.0952 ), +}; + +static final StrokeRec char71[] = { + new StrokeRec(19, char71_stroke0), + new StrokeRec(2, char71_stroke1), +}; + +/* char: 72 'H' */ + +static final CoordRec[] char72_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char72_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char72_stroke2 = { + new CoordRec( (float) 19.0476, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 52.381 ), +}; + +static final StrokeRec char72[] = { + new StrokeRec(2, char72_stroke0), + new StrokeRec(2, char72_stroke1), + new StrokeRec(2, char72_stroke2), +}; + +/* char: 73 'I' */ + +static final CoordRec[] char73_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char73[] = { + new StrokeRec(2, char73_stroke0), +}; + +/* char: 74 'J' */ + +static final CoordRec[] char74_stroke0 = { + new CoordRec( (float) 76.1905, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 23.8095 ), + new CoordRec( (float) 71.4286, (float) 9.5238 ), + new CoordRec( (float) 66.6667, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 0 ), + new CoordRec( (float) 38.0953, (float) 4.7619 ), + new CoordRec( (float) 33.3334, (float) 9.5238 ), + new CoordRec( (float) 28.5715, (float) 23.8095 ), + new CoordRec( (float) 28.5715, (float) 33.3333 ), +}; + +static final StrokeRec char74[] = { + new StrokeRec(10, char74_stroke0), +}; + +/* char: 75 'K' */ + +static final CoordRec[] char75_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char75_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 33.3333 ), +}; + +static final CoordRec[] char75_stroke2 = { + new CoordRec( (float) 42.8571, (float) 57.1429 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char75[] = { + new StrokeRec(2, char75_stroke0), + new StrokeRec(2, char75_stroke1), + new StrokeRec(2, char75_stroke2), +}; + +/* char: 76 'L' */ + +static final CoordRec[] char76_stroke0 = { + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 0 ), +}; + +static final CoordRec[] char76_stroke1 = { + new CoordRec( (float) 23.8095, (float) 0 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final StrokeRec char76[] = { + new StrokeRec(2, char76_stroke0), + new StrokeRec(2, char76_stroke1), +}; + +/* char: 77 'M' */ + +static final CoordRec[] char77_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final CoordRec[] char77_stroke1 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char77_stroke2 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char77_stroke3 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final StrokeRec char77[] = { + new StrokeRec(2, char77_stroke0), + new StrokeRec(2, char77_stroke1), + new StrokeRec(2, char77_stroke2), + new StrokeRec(2, char77_stroke3), +}; + +/* char: 78 'N' */ + +static final CoordRec[] char78_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char78_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char78_stroke2 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char78[] = { + new StrokeRec(2, char78_stroke0), + new StrokeRec(2, char78_stroke1), + new StrokeRec(2, char78_stroke2), +}; + +/* char: 79 'O' */ + +static final CoordRec[] char79_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 14.2857, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 23.8095 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 90.4762, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final StrokeRec char79[] = { + new StrokeRec(21, char79_stroke0), +}; + +/* char: 80 'P' */ + +static final CoordRec[] char80_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char80_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 57.1429 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 61.9047, (float) 47.619 ), + new CoordRec( (float) 19.0476, (float) 47.619 ), +}; + +static final StrokeRec char80[] = { + new StrokeRec(2, char80_stroke0), + new StrokeRec(10, char80_stroke1), +}; + +/* char: 81 'Q' */ + +static final CoordRec[] char81_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 14.2857, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 23.8095 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 90.4762, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final CoordRec[] char81_stroke1 = { + new CoordRec( (float) 57.1428, (float) 19.0476 ), + new CoordRec( (float) 85.7143, (float) -9.5238 ), +}; + +static final StrokeRec char81[] = { + new StrokeRec(21, char81_stroke0), + new StrokeRec(2, char81_stroke1), +}; + +/* char: 82 'R' */ + +static final CoordRec[] char82_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char82_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 71.4286 ), + new CoordRec( (float) 80.9524, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), + new CoordRec( (float) 19.0476, (float) 52.381 ), +}; + +static final CoordRec[] char82_stroke2 = { + new CoordRec( (float) 52.3809, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char82[] = { + new StrokeRec(2, char82_stroke0), + new StrokeRec(10, char82_stroke1), + new StrokeRec(2, char82_stroke2), +}; + +/* char: 83 'S' */ + +static final CoordRec[] char83_stroke0 = { + new CoordRec( (float) 85.7143, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 19.0476, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 19.0476, (float) 14.2857 ), +}; + +static final StrokeRec char83[] = { + new StrokeRec(20, char83_stroke0), +}; + +/* char: 84 'T' */ + +static final CoordRec[] char84_stroke0 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char84_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char84[] = { + new StrokeRec(2, char84_stroke0), + new StrokeRec(2, char84_stroke1), +}; + +/* char: 85 'U' */ + +static final CoordRec[] char85_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 28.5714 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char85[] = { + new StrokeRec(10, char85_stroke0), +}; + +/* char: 86 'V' */ + +static final CoordRec[] char86_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char86_stroke1 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final StrokeRec char86[] = { + new StrokeRec(2, char86_stroke0), + new StrokeRec(2, char86_stroke1), +}; + +/* char: 87 'W' */ + +static final CoordRec[] char87_stroke0 = { + new CoordRec( (float) 4.7619, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 0 ), +}; + +static final CoordRec[] char87_stroke1 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 0 ), +}; + +static final CoordRec[] char87_stroke2 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 0 ), +}; + +static final CoordRec[] char87_stroke3 = { + new CoordRec( (float) 100, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 0 ), +}; + +static final StrokeRec char87[] = { + new StrokeRec(2, char87_stroke0), + new StrokeRec(2, char87_stroke1), + new StrokeRec(2, char87_stroke2), + new StrokeRec(2, char87_stroke3), +}; + +/* char: 88 'X' */ + +static final CoordRec[] char88_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char88_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char88[] = { + new StrokeRec(2, char88_stroke0), + new StrokeRec(2, char88_stroke1), +}; + +/* char: 89 'Y' */ + +static final CoordRec[] char89_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 52.381 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char89_stroke1 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 52.381 ), +}; + +static final StrokeRec char89[] = { + new StrokeRec(3, char89_stroke0), + new StrokeRec(2, char89_stroke1), +}; + +/* char: 90 'Z' */ + +static final CoordRec[] char90_stroke0 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char90_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final CoordRec[] char90_stroke2 = { + new CoordRec( (float) 19.0476, (float) 0 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char90[] = { + new StrokeRec(2, char90_stroke0), + new StrokeRec(2, char90_stroke1), + new StrokeRec(2, char90_stroke2), +}; + +/* char: 91 '[' */ + +static final CoordRec[] char91_stroke0 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 35.7143, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke1 = { + new CoordRec( (float) 40.4762, (float) 119.048 ), + new CoordRec( (float) 40.4762, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke2 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) 119.048 ), +}; + +static final CoordRec[] char91_stroke3 = { + new CoordRec( (float) 35.7143, (float) -33.3333 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char91[] = { + new StrokeRec(2, char91_stroke0), + new StrokeRec(2, char91_stroke1), + new StrokeRec(2, char91_stroke2), + new StrokeRec(2, char91_stroke3), +}; + +/* char: 92 '\' */ + +static final CoordRec[] char92_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) -14.2857 ), +}; + +static final StrokeRec char92[] = { + new StrokeRec(2, char92_stroke0), +}; + +/* char: 93 ']' */ + +static final CoordRec[] char93_stroke0 = { + new CoordRec( (float) 64.2857, (float) 119.048 ), + new CoordRec( (float) 64.2857, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke1 = { + new CoordRec( (float) 69.0476, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke2 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) 119.048 ), +}; + +static final CoordRec[] char93_stroke3 = { + new CoordRec( (float) 35.7143, (float) -33.3333 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char93[] = { + new StrokeRec(2, char93_stroke0), + new StrokeRec(2, char93_stroke1), + new StrokeRec(2, char93_stroke2), + new StrokeRec(2, char93_stroke3), +}; + +/* char: 94 '^' */ + +static final CoordRec[] char94_stroke0 = { + new CoordRec( (float) 52.3809, (float) 109.524 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), +}; + +static final CoordRec[] char94_stroke1 = { + new CoordRec( (float) 52.3809, (float) 109.524 ), + new CoordRec( (float) 90.4762, (float) 42.8571 ), +}; + +static final StrokeRec char94[] = { + new StrokeRec(2, char94_stroke0), + new StrokeRec(2, char94_stroke1), +}; + +/* char: 95 '_' */ + +static final CoordRec[] char95_stroke0 = { + new CoordRec( (float) 0, (float) -33.3333 ), + new CoordRec( (float) 104.762, (float) -33.3333 ), + new CoordRec( (float) 104.762, (float) -28.5714 ), + new CoordRec( (float) 0, (float) -28.5714 ), + new CoordRec( (float) 0, (float) -33.3333 ), +}; + +static final StrokeRec char95[] = { + new StrokeRec(5, char95_stroke0), +}; + +/* char: 96 '`' */ + +static final CoordRec[] char96_stroke0 = { + new CoordRec( (float) 42.8572, (float) 100 ), + new CoordRec( (float) 66.6667, (float) 71.4286 ), +}; + +static final CoordRec[] char96_stroke1 = { + new CoordRec( (float) 42.8572, (float) 100 ), + new CoordRec( (float) 38.0953, (float) 95.2381 ), + new CoordRec( (float) 66.6667, (float) 71.4286 ), +}; + +static final StrokeRec char96[] = { + new StrokeRec(2, char96_stroke0), + new StrokeRec(3, char96_stroke1), +}; + +/* char: 97 'a' */ + +static final CoordRec[] char97_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final CoordRec[] char97_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char97[] = { + new StrokeRec(2, char97_stroke0), + new StrokeRec(14, char97_stroke1), +}; + +/* char: 98 'b' */ + +static final CoordRec[] char98_stroke0 = { + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 0 ), +}; + +static final CoordRec[] char98_stroke1 = { + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), +}; + +static final StrokeRec char98[] = { + new StrokeRec(2, char98_stroke0), + new StrokeRec(14, char98_stroke1), +}; + +/* char: 99 'c' */ + +static final CoordRec[] char99_stroke0 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char99[] = { + new StrokeRec(14, char99_stroke0), +}; + +/* char: 100 'd' */ + +static final CoordRec[] char100_stroke0 = { + new CoordRec( (float) 80.9524, (float) 100 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final CoordRec[] char100_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char100[] = { + new StrokeRec(2, char100_stroke0), + new StrokeRec(14, char100_stroke1), +}; + +/* char: 101 'e' */ + +static final CoordRec[] char101_stroke0 = { + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char101[] = { + new StrokeRec(17, char101_stroke0), +}; + +/* char: 102 'f' */ + +static final CoordRec[] char102_stroke0 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 100 ), + new CoordRec( (float) 52.381, (float) 95.2381 ), + new CoordRec( (float) 47.6191, (float) 80.9524 ), + new CoordRec( (float) 47.6191, (float) 0 ), +}; + +static final CoordRec[] char102_stroke1 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 66.6667, (float) 66.6667 ), +}; + +static final StrokeRec char102[] = { + new StrokeRec(5, char102_stroke0), + new StrokeRec(2, char102_stroke1), +}; + +/* char: 103 'g' */ + +static final CoordRec[] char103_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) -9.5238 ), + new CoordRec( (float) 76.1905, (float) -23.8095 ), + new CoordRec( (float) 71.4285, (float) -28.5714 ), + new CoordRec( (float) 61.9047, (float) -33.3333 ), + new CoordRec( (float) 47.619, (float) -33.3333 ), + new CoordRec( (float) 38.0952, (float) -28.5714 ), +}; + +static final CoordRec[] char103_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char103[] = { + new StrokeRec(7, char103_stroke0), + new StrokeRec(14, char103_stroke1), +}; + +/* char: 104 'h' */ + +static final CoordRec[] char104_stroke0 = { + new CoordRec( (float) 26.1905, (float) 100 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char104_stroke1 = { + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 66.6667 ), + new CoordRec( (float) 64.2857, (float) 66.6667 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 78.5715, (float) 47.619 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char104[] = { + new StrokeRec(2, char104_stroke0), + new StrokeRec(7, char104_stroke1), +}; + +/* char: 105 'i' */ + +static final CoordRec[] char105_stroke0 = { + new CoordRec( (float) 47.6191, (float) 100 ), + new CoordRec( (float) 52.381, (float) 95.2381 ), + new CoordRec( (float) 57.1429, (float) 100 ), + new CoordRec( (float) 52.381, (float) 104.762 ), + new CoordRec( (float) 47.6191, (float) 100 ), +}; + +static final CoordRec[] char105_stroke1 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char105[] = { + new StrokeRec(5, char105_stroke0), + new StrokeRec(2, char105_stroke1), +}; + +/* char: 106 'j' */ + +static final CoordRec[] char106_stroke0 = { + new CoordRec( (float) 57.1429, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 95.2381 ), + new CoordRec( (float) 66.6667, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 104.762 ), + new CoordRec( (float) 57.1429, (float) 100 ), +}; + +static final CoordRec[] char106_stroke1 = { + new CoordRec( (float) 61.9048, (float) 66.6667 ), + new CoordRec( (float) 61.9048, (float) -14.2857 ), + new CoordRec( (float) 57.1429, (float) -28.5714 ), + new CoordRec( (float) 47.6191, (float) -33.3333 ), + new CoordRec( (float) 38.0953, (float) -33.3333 ), +}; + +static final StrokeRec char106[] = { + new StrokeRec(5, char106_stroke0), + new StrokeRec(5, char106_stroke1), +}; + +/* char: 107 'k' */ + +static final CoordRec[] char107_stroke0 = { + new CoordRec( (float) 26.1905, (float) 100 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char107_stroke1 = { + new CoordRec( (float) 73.8095, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 19.0476 ), +}; + +static final CoordRec[] char107_stroke2 = { + new CoordRec( (float) 45.2381, (float) 38.0952 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char107[] = { + new StrokeRec(2, char107_stroke0), + new StrokeRec(2, char107_stroke1), + new StrokeRec(2, char107_stroke2), +}; + +/* char: 108 'l' */ + +static final CoordRec[] char108_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char108[] = { + new StrokeRec(2, char108_stroke0), +}; + +/* char: 109 'm' */ + +static final CoordRec[] char109_stroke0 = { + new CoordRec( (float) 0, (float) 66.6667 ), + new CoordRec( (float) 0, (float) 0 ), +}; + +static final CoordRec[] char109_stroke1 = { + new CoordRec( (float) 0, (float) 47.619 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 47.619 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final CoordRec[] char109_stroke2 = { + new CoordRec( (float) 52.381, (float) 47.619 ), + new CoordRec( (float) 66.6667, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 66.6667 ), + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 100, (float) 61.9048 ), + new CoordRec( (float) 104.762, (float) 47.619 ), + new CoordRec( (float) 104.762, (float) 0 ), +}; + +static final StrokeRec char109[] = { + new StrokeRec(2, char109_stroke0), + new StrokeRec(7, char109_stroke1), + new StrokeRec(7, char109_stroke2), +}; + +/* char: 110 'n' */ + +static final CoordRec[] char110_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char110_stroke1 = { + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 66.6667 ), + new CoordRec( (float) 64.2857, (float) 66.6667 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 78.5715, (float) 47.619 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char110[] = { + new StrokeRec(2, char110_stroke0), + new StrokeRec(7, char110_stroke1), +}; + +/* char: 111 'o' */ + +static final CoordRec[] char111_stroke0 = { + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 35.7143, (float) 61.9048 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 21.4286, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 28.5714 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 59.5238, (float) 0 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 78.5714, (float) 14.2857 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 38.0952 ), + new CoordRec( (float) 78.5714, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), +}; + +static final StrokeRec char111[] = { + new StrokeRec(17, char111_stroke0), +}; + +/* char: 112 'p' */ + +static final CoordRec[] char112_stroke0 = { + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 23.8095, (float) -33.3333 ), +}; + +static final CoordRec[] char112_stroke1 = { + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), +}; + +static final StrokeRec char112[] = { + new StrokeRec(2, char112_stroke0), + new StrokeRec(14, char112_stroke1), +}; + +/* char: 113 'q' */ + +static final CoordRec[] char113_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) -33.3333 ), +}; + +static final CoordRec[] char113_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char113[] = { + new StrokeRec(2, char113_stroke0), + new StrokeRec(14, char113_stroke1), +}; + +/* char: 114 'r' */ + +static final CoordRec[] char114_stroke0 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 33.3334, (float) 0 ), +}; + +static final CoordRec[] char114_stroke1 = { + new CoordRec( (float) 33.3334, (float) 38.0952 ), + new CoordRec( (float) 38.0953, (float) 52.381 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 57.1429, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 66.6667 ), +}; + +static final StrokeRec char114[] = { + new StrokeRec(2, char114_stroke0), + new StrokeRec(5, char114_stroke1), +}; + +/* char: 115 's' */ + +static final CoordRec[] char115_stroke0 = { + new CoordRec( (float) 78.5715, (float) 52.381 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 30.9524, (float) 61.9048 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 30.9524, (float) 42.8571 ), + new CoordRec( (float) 40.4762, (float) 38.0952 ), + new CoordRec( (float) 64.2857, (float) 33.3333 ), + new CoordRec( (float) 73.8095, (float) 28.5714 ), + new CoordRec( (float) 78.5715, (float) 19.0476 ), + new CoordRec( (float) 78.5715, (float) 14.2857 ), + new CoordRec( (float) 73.8095, (float) 4.7619 ), + new CoordRec( (float) 59.5238, (float) 0 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), +}; + +static final StrokeRec char115[] = { + new StrokeRec(17, char115_stroke0), +}; + +/* char: 116 't' */ + +static final CoordRec[] char116_stroke0 = { + new CoordRec( (float) 47.6191, (float) 100 ), + new CoordRec( (float) 47.6191, (float) 19.0476 ), + new CoordRec( (float) 52.381, (float) 4.7619 ), + new CoordRec( (float) 61.9048, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final CoordRec[] char116_stroke1 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 66.6667, (float) 66.6667 ), +}; + +static final StrokeRec char116[] = { + new StrokeRec(5, char116_stroke0), + new StrokeRec(2, char116_stroke1), +}; + +/* char: 117 'u' */ + +static final CoordRec[] char117_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 19.0476 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 40.4762, (float) 0 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 4.7619 ), + new CoordRec( (float) 78.5715, (float) 19.0476 ), +}; + +static final CoordRec[] char117_stroke1 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char117[] = { + new StrokeRec(7, char117_stroke0), + new StrokeRec(2, char117_stroke1), +}; + +/* char: 118 'v' */ + +static final CoordRec[] char118_stroke0 = { + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char118_stroke1 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final StrokeRec char118[] = { + new StrokeRec(2, char118_stroke0), + new StrokeRec(2, char118_stroke1), +}; + +/* char: 119 'w' */ + +static final CoordRec[] char119_stroke0 = { + new CoordRec( (float) 14.2857, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 0 ), +}; + +static final CoordRec[] char119_stroke1 = { + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 0 ), +}; + +static final CoordRec[] char119_stroke2 = { + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final CoordRec[] char119_stroke3 = { + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final StrokeRec char119[] = { + new StrokeRec(2, char119_stroke0), + new StrokeRec(2, char119_stroke1), + new StrokeRec(2, char119_stroke2), + new StrokeRec(2, char119_stroke3), +}; + +/* char: 120 'x' */ + +static final CoordRec[] char120_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final CoordRec[] char120_stroke1 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final StrokeRec char120[] = { + new StrokeRec(2, char120_stroke0), + new StrokeRec(2, char120_stroke1), +}; + +/* char: 121 'y' */ + +static final CoordRec[] char121_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 54.7619, (float) 0 ), +}; + +static final CoordRec[] char121_stroke1 = { + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 45.2381, (float) -19.0476 ), + new CoordRec( (float) 35.7143, (float) -28.5714 ), + new CoordRec( (float) 26.1905, (float) -33.3333 ), + new CoordRec( (float) 21.4286, (float) -33.3333 ), +}; + +static final StrokeRec char121[] = { + new StrokeRec(2, char121_stroke0), + new StrokeRec(6, char121_stroke1), +}; + +/* char: 122 'z' */ + +static final CoordRec[] char122_stroke0 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char122_stroke1 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 66.6667 ), +}; + +static final CoordRec[] char122_stroke2 = { + new CoordRec( (float) 26.1905, (float) 0 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char122[] = { + new StrokeRec(2, char122_stroke0), + new StrokeRec(2, char122_stroke1), + new StrokeRec(2, char122_stroke2), +}; + +/* char: 123 '{' */ + +static final CoordRec[] char123_stroke0 = { + new CoordRec( (float) 64.2857, (float) 119.048 ), + new CoordRec( (float) 54.7619, (float) 114.286 ), + new CoordRec( (float) 50, (float) 109.524 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 90.4762 ), + new CoordRec( (float) 50, (float) 80.9524 ), + new CoordRec( (float) 54.7619, (float) 76.1905 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 59.5238, (float) 57.1429 ), + new CoordRec( (float) 50, (float) 47.619 ), +}; + +static final CoordRec[] char123_stroke1 = { + new CoordRec( (float) 54.7619, (float) 114.286 ), + new CoordRec( (float) 50, (float) 104.762 ), + new CoordRec( (float) 50, (float) 95.2381 ), + new CoordRec( (float) 54.7619, (float) 85.7143 ), + new CoordRec( (float) 59.5238, (float) 80.9524 ), + new CoordRec( (float) 64.2857, (float) 71.4286 ), + new CoordRec( (float) 64.2857, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), + new CoordRec( (float) 40.4762, (float) 42.8571 ), + new CoordRec( (float) 59.5238, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 23.8095 ), + new CoordRec( (float) 64.2857, (float) 14.2857 ), + new CoordRec( (float) 59.5238, (float) 4.7619 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 50, (float) -9.5238 ), + new CoordRec( (float) 50, (float) -19.0476 ), + new CoordRec( (float) 54.7619, (float) -28.5714 ), +}; + +static final CoordRec[] char123_stroke2 = { + new CoordRec( (float) 50, (float) 38.0952 ), + new CoordRec( (float) 59.5238, (float) 28.5714 ), + new CoordRec( (float) 59.5238, (float) 19.0476 ), + new CoordRec( (float) 54.7619, (float) 9.5238 ), + new CoordRec( (float) 50, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) -4.7619 ), + new CoordRec( (float) 45.2381, (float) -14.2857 ), + new CoordRec( (float) 50, (float) -23.8095 ), + new CoordRec( (float) 54.7619, (float) -28.5714 ), + new CoordRec( (float) 64.2857, (float) -33.3333 ), +}; + +static final StrokeRec char123[] = { + new StrokeRec(10, char123_stroke0), + new StrokeRec(17, char123_stroke1), + new StrokeRec(10, char123_stroke2), +}; + +/* char: 124 '|' */ + +static final CoordRec[] char124_stroke0 = { + new CoordRec( (float) 52.381, (float) 119.048 ), + new CoordRec( (float) 52.381, (float) -33.3333 ), +}; + +static final StrokeRec char124[] = { + new StrokeRec(2, char124_stroke0), +}; + +/* char: 125 '}' */ + +static final CoordRec[] char125_stroke0 = { + new CoordRec( (float) 40.4762, (float) 119.048 ), + new CoordRec( (float) 50, (float) 114.286 ), + new CoordRec( (float) 54.7619, (float) 109.524 ), + new CoordRec( (float) 59.5238, (float) 100 ), + new CoordRec( (float) 59.5238, (float) 90.4762 ), + new CoordRec( (float) 54.7619, (float) 80.9524 ), + new CoordRec( (float) 50, (float) 76.1905 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 57.1429 ), + new CoordRec( (float) 54.7619, (float) 47.619 ), +}; + +static final CoordRec[] char125_stroke1 = { + new CoordRec( (float) 50, (float) 114.286 ), + new CoordRec( (float) 54.7619, (float) 104.762 ), + new CoordRec( (float) 54.7619, (float) 95.2381 ), + new CoordRec( (float) 50, (float) 85.7143 ), + new CoordRec( (float) 45.2381, (float) 80.9524 ), + new CoordRec( (float) 40.4762, (float) 71.4286 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 45.2381, (float) 52.381 ), + new CoordRec( (float) 64.2857, (float) 42.8571 ), + new CoordRec( (float) 45.2381, (float) 33.3333 ), + new CoordRec( (float) 40.4762, (float) 23.8095 ), + new CoordRec( (float) 40.4762, (float) 14.2857 ), + new CoordRec( (float) 45.2381, (float) 4.7619 ), + new CoordRec( (float) 50, (float) 0 ), + new CoordRec( (float) 54.7619, (float) -9.5238 ), + new CoordRec( (float) 54.7619, (float) -19.0476 ), + new CoordRec( (float) 50, (float) -28.5714 ), +}; + +static final CoordRec[] char125_stroke2 = { + new CoordRec( (float) 54.7619, (float) 38.0952 ), + new CoordRec( (float) 45.2381, (float) 28.5714 ), + new CoordRec( (float) 45.2381, (float) 19.0476 ), + new CoordRec( (float) 50, (float) 9.5238 ), + new CoordRec( (float) 54.7619, (float) 4.7619 ), + new CoordRec( (float) 59.5238, (float) -4.7619 ), + new CoordRec( (float) 59.5238, (float) -14.2857 ), + new CoordRec( (float) 54.7619, (float) -23.8095 ), + new CoordRec( (float) 50, (float) -28.5714 ), + new CoordRec( (float) 40.4762, (float) -33.3333 ), +}; + +static final StrokeRec char125[] = { + new StrokeRec(10, char125_stroke0), + new StrokeRec(17, char125_stroke1), + new StrokeRec(10, char125_stroke2), +}; + +/* char: 126 '~' */ + +static final CoordRec[] char126_stroke0 = { + new CoordRec( (float) 9.5238, (float) 28.5714 ), + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 57.1429 ), + new CoordRec( (float) 33.3333, (float) 57.1429 ), + new CoordRec( (float) 42.8571, (float) 52.381 ), + new CoordRec( (float) 61.9048, (float) 38.0952 ), + new CoordRec( (float) 71.4286, (float) 33.3333 ), + new CoordRec( (float) 80.9524, (float) 33.3333 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 95.2381, (float) 47.619 ), +}; + +static final CoordRec[] char126_stroke1 = { + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 47.619 ), + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 52.381 ), + new CoordRec( (float) 42.8571, (float) 47.619 ), + new CoordRec( (float) 61.9048, (float) 33.3333 ), + new CoordRec( (float) 71.4286, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 90.4762, (float) 33.3333 ), + new CoordRec( (float) 95.2381, (float) 47.619 ), + new CoordRec( (float) 95.2381, (float) 57.1429 ), +}; + +static final StrokeRec char126[] = { + new StrokeRec(11, char126_stroke0), + new StrokeRec(11, char126_stroke1), +}; + +/* char: 127 */ + +static final CoordRec[] char127_stroke0 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 33.3333, (float) -33.3333 ), +}; + +static final CoordRec[] char127_stroke1 = { + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 19.0476, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4286, (float) 61.9048 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), +}; + +static final StrokeRec char127[] = { + new StrokeRec(2, char127_stroke0), + new StrokeRec(17, char127_stroke1), +}; + +static final StrokeCharRec chars[] = { + new StrokeCharRec( 0, /* char0 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char1 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char2 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char3 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char4 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char5 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char6 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char7 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char8 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char9 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char10 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char11 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char12 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char13 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char14 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char15 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char16 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char17 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char18 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char19 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char20 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char21 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char22 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char23 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char24 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char25 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char26 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char27 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char28 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char29 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char30 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char31 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char32 */ null, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char33, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char34, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char35, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char36, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char37, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char38, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char39, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char40, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char41, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char42, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char43, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char44, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char45, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char46, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char47, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char48, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char49, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char50, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char51, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char52, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char53, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char54, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char55, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char56, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char57, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char58, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char59, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char60, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char61, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char62, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char63, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char64, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char65, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char66, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char67, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char68, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char69, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char70, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char71, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char72, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char73, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char74, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char75, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char76, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char77, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char78, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char79, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char80, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char81, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char82, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char83, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char84, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char85, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char86, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char87, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char88, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char89, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char90, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char91, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char92, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char93, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char94, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char95, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char96, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char97, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char98, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char99, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char100, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char101, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char102, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char103, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char104, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char105, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char106, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char107, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char108, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char109, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char110, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char111, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char112, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char113, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char114, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char115, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char116, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char117, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char118, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char119, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char120, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char121, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char122, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char123, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char124, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char125, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char126, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char127, (float)52.381, (float)104.762 ), +}; + +final static StrokeFontRec fontinfo = new StrokeFontRec( "Roman", 128, chars, (float)119.048, (float)-33.3333 ); + + static public StrokeFontRec getStrokeFontRec() { + return fontinfo; + } +} diff --git a/gl4java/utils/glut/fonts/data/glutStrokeRoman.java b/gl4java/utils/glut/fonts/data/glutStrokeRoman.java new file mode 100644 index 0000000..614454d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutStrokeRoman.java @@ -0,0 +1,2458 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + +public class glutStrokeRoman implements GLUTStrokeFont { +/* char: 33 '!' */ + +static final CoordRec[] char33_stroke0 = { + new CoordRec( (float) 13.3819, (float) 100 ), + new CoordRec( (float) 13.3819, (float) 33.3333 ), +}; + +static final CoordRec[] char33_stroke1 = { + new CoordRec( (float) 13.3819, (float) 9.5238 ), + new CoordRec( (float) 8.62, (float) 4.7619 ), + new CoordRec( (float) 13.3819, (float) 0 ), + new CoordRec( (float) 18.1438, (float) 4.7619 ), + new CoordRec( (float) 13.3819, (float) 9.5238 ), +}; + +static final StrokeRec char33[] = { + new StrokeRec(2, char33_stroke0), + new StrokeRec(5, char33_stroke1), +}; + +/* char: 34 '"' */ + +static final CoordRec[] char34_stroke0 = { + new CoordRec( (float) 4.02, (float) 100 ), + new CoordRec( (float) 4.02, (float) 66.6667 ), +}; + +static final CoordRec[] char34_stroke1 = { + new CoordRec( (float) 42.1152, (float) 100 ), + new CoordRec( (float) 42.1152, (float) 66.6667 ), +}; + +static final StrokeRec char34[] = { + new StrokeRec(2, char34_stroke0), + new StrokeRec(2, char34_stroke1), +}; + +/* char: 35 '#' */ + +static final CoordRec[] char35_stroke0 = { + new CoordRec( (float) 41.2952, (float) 119.048 ), + new CoordRec( (float) 7.9619, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke1 = { + new CoordRec( (float) 69.8667, (float) 119.048 ), + new CoordRec( (float) 36.5333, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke2 = { + new CoordRec( (float) 7.9619, (float) 57.1429 ), + new CoordRec( (float) 74.6286, (float) 57.1429 ), +}; + +static final CoordRec[] char35_stroke3 = { + new CoordRec( (float) 3.2, (float) 28.5714 ), + new CoordRec( (float) 69.8667, (float) 28.5714 ), +}; + +static final StrokeRec char35[] = { + new StrokeRec(2, char35_stroke0), + new StrokeRec(2, char35_stroke1), + new StrokeRec(2, char35_stroke2), + new StrokeRec(2, char35_stroke3), +}; + +/* char: 36 '$' */ + +static final CoordRec[] char36_stroke0 = { + new CoordRec( (float) 28.6295, (float) 119.048 ), + new CoordRec( (float) 28.6295, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke1 = { + new CoordRec( (float) 47.6771, (float) 119.048 ), + new CoordRec( (float) 47.6771, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke2 = { + new CoordRec( (float) 71.4867, (float) 85.7143 ), + new CoordRec( (float) 61.9629, (float) 95.2381 ), + new CoordRec( (float) 47.6771, (float) 100 ), + new CoordRec( (float) 28.6295, (float) 100 ), + new CoordRec( (float) 14.3438, (float) 95.2381 ), + new CoordRec( (float) 4.82, (float) 85.7143 ), + new CoordRec( (float) 4.82, (float) 76.1905 ), + new CoordRec( (float) 9.5819, (float) 66.6667 ), + new CoordRec( (float) 14.3438, (float) 61.9048 ), + new CoordRec( (float) 23.8676, (float) 57.1429 ), + new CoordRec( (float) 52.439, (float) 47.619 ), + new CoordRec( (float) 61.9629, (float) 42.8571 ), + new CoordRec( (float) 66.7248, (float) 38.0952 ), + new CoordRec( (float) 71.4867, (float) 28.5714 ), + new CoordRec( (float) 71.4867, (float) 14.2857 ), + new CoordRec( (float) 61.9629, (float) 4.7619 ), + new CoordRec( (float) 47.6771, (float) 0 ), + new CoordRec( (float) 28.6295, (float) 0 ), + new CoordRec( (float) 14.3438, (float) 4.7619 ), + new CoordRec( (float) 4.82, (float) 14.2857 ), +}; + +static final StrokeRec char36[] = { + new StrokeRec(2, char36_stroke0), + new StrokeRec(2, char36_stroke1), + new StrokeRec(20, char36_stroke2), +}; + +/* char: 37 '%' */ + +static final CoordRec[] char37_stroke0 = { + new CoordRec( (float) 92.0743, (float) 100 ), + new CoordRec( (float) 6.36, (float) 0 ), +}; + +static final CoordRec[] char37_stroke1 = { + new CoordRec( (float) 30.1695, (float) 100 ), + new CoordRec( (float) 39.6933, (float) 90.4762 ), + new CoordRec( (float) 39.6933, (float) 80.9524 ), + new CoordRec( (float) 34.9314, (float) 71.4286 ), + new CoordRec( (float) 25.4076, (float) 66.6667 ), + new CoordRec( (float) 15.8838, (float) 66.6667 ), + new CoordRec( (float) 6.36, (float) 76.1905 ), + new CoordRec( (float) 6.36, (float) 85.7143 ), + new CoordRec( (float) 11.1219, (float) 95.2381 ), + new CoordRec( (float) 20.6457, (float) 100 ), + new CoordRec( (float) 30.1695, (float) 100 ), + new CoordRec( (float) 39.6933, (float) 95.2381 ), + new CoordRec( (float) 53.979, (float) 90.4762 ), + new CoordRec( (float) 68.2648, (float) 90.4762 ), + new CoordRec( (float) 82.5505, (float) 95.2381 ), + new CoordRec( (float) 92.0743, (float) 100 ), +}; + +static final CoordRec[] char37_stroke2 = { + new CoordRec( (float) 73.0267, (float) 33.3333 ), + new CoordRec( (float) 63.5029, (float) 28.5714 ), + new CoordRec( (float) 58.741, (float) 19.0476 ), + new CoordRec( (float) 58.741, (float) 9.5238 ), + new CoordRec( (float) 68.2648, (float) 0 ), + new CoordRec( (float) 77.7886, (float) 0 ), + new CoordRec( (float) 87.3124, (float) 4.7619 ), + new CoordRec( (float) 92.0743, (float) 14.2857 ), + new CoordRec( (float) 92.0743, (float) 23.8095 ), + new CoordRec( (float) 82.5505, (float) 33.3333 ), + new CoordRec( (float) 73.0267, (float) 33.3333 ), +}; + +static final StrokeRec char37[] = { + new StrokeRec(2, char37_stroke0), + new StrokeRec(16, char37_stroke1), + new StrokeRec(11, char37_stroke2), +}; + +/* char: 38 '&' */ + +static final CoordRec[] char38_stroke0 = { + new CoordRec( (float) 101.218, (float) 57.1429 ), + new CoordRec( (float) 101.218, (float) 61.9048 ), + new CoordRec( (float) 96.4562, (float) 66.6667 ), + new CoordRec( (float) 91.6943, (float) 66.6667 ), + new CoordRec( (float) 86.9324, (float) 61.9048 ), + new CoordRec( (float) 82.1705, (float) 52.381 ), + new CoordRec( (float) 72.6467, (float) 28.5714 ), + new CoordRec( (float) 63.1229, (float) 14.2857 ), + new CoordRec( (float) 53.599, (float) 4.7619 ), + new CoordRec( (float) 44.0752, (float) 0 ), + new CoordRec( (float) 25.0276, (float) 0 ), + new CoordRec( (float) 15.5038, (float) 4.7619 ), + new CoordRec( (float) 10.7419, (float) 9.5238 ), + new CoordRec( (float) 5.98, (float) 19.0476 ), + new CoordRec( (float) 5.98, (float) 28.5714 ), + new CoordRec( (float) 10.7419, (float) 38.0952 ), + new CoordRec( (float) 15.5038, (float) 42.8571 ), + new CoordRec( (float) 48.8371, (float) 61.9048 ), + new CoordRec( (float) 53.599, (float) 66.6667 ), + new CoordRec( (float) 58.361, (float) 76.1905 ), + new CoordRec( (float) 58.361, (float) 85.7143 ), + new CoordRec( (float) 53.599, (float) 95.2381 ), + new CoordRec( (float) 44.0752, (float) 100 ), + new CoordRec( (float) 34.5514, (float) 95.2381 ), + new CoordRec( (float) 29.7895, (float) 85.7143 ), + new CoordRec( (float) 29.7895, (float) 76.1905 ), + new CoordRec( (float) 34.5514, (float) 61.9048 ), + new CoordRec( (float) 44.0752, (float) 47.619 ), + new CoordRec( (float) 67.8848, (float) 14.2857 ), + new CoordRec( (float) 77.4086, (float) 4.7619 ), + new CoordRec( (float) 86.9324, (float) 0 ), + new CoordRec( (float) 96.4562, (float) 0 ), + new CoordRec( (float) 101.218, (float) 4.7619 ), + new CoordRec( (float) 101.218, (float) 9.5238 ), +}; + +static final StrokeRec char38[] = { + new StrokeRec(34, char38_stroke0), +}; + +/* char: 39 ''' */ + +static final CoordRec[] char39_stroke0 = { + new CoordRec( (float) 4.44, (float) 100 ), + new CoordRec( (float) 4.44, (float) 66.6667 ), +}; + +static final StrokeRec char39[] = { + new StrokeRec(2, char39_stroke0), +}; + +/* char: 40 '(' */ + +static final CoordRec[] char40_stroke0 = { + new CoordRec( (float) 40.9133, (float) 119.048 ), + new CoordRec( (float) 31.3895, (float) 109.524 ), + new CoordRec( (float) 21.8657, (float) 95.2381 ), + new CoordRec( (float) 12.3419, (float) 76.1905 ), + new CoordRec( (float) 7.58, (float) 52.381 ), + new CoordRec( (float) 7.58, (float) 33.3333 ), + new CoordRec( (float) 12.3419, (float) 9.5238 ), + new CoordRec( (float) 21.8657, (float) -9.5238 ), + new CoordRec( (float) 31.3895, (float) -23.8095 ), + new CoordRec( (float) 40.9133, (float) -33.3333 ), +}; + +static final StrokeRec char40[] = { + new StrokeRec(10, char40_stroke0), +}; + +/* char: 41 ')' */ + +static final CoordRec[] char41_stroke0 = { + new CoordRec( (float) 5.28, (float) 119.048 ), + new CoordRec( (float) 14.8038, (float) 109.524 ), + new CoordRec( (float) 24.3276, (float) 95.2381 ), + new CoordRec( (float) 33.8514, (float) 76.1905 ), + new CoordRec( (float) 38.6133, (float) 52.381 ), + new CoordRec( (float) 38.6133, (float) 33.3333 ), + new CoordRec( (float) 33.8514, (float) 9.5238 ), + new CoordRec( (float) 24.3276, (float) -9.5238 ), + new CoordRec( (float) 14.8038, (float) -23.8095 ), + new CoordRec( (float) 5.28, (float) -33.3333 ), +}; + +static final StrokeRec char41[] = { + new StrokeRec(10, char41_stroke0), +}; + +/* char: 42 '*' */ + +static final CoordRec[] char42_stroke0 = { + new CoordRec( (float) 30.7695, (float) 71.4286 ), + new CoordRec( (float) 30.7695, (float) 14.2857 ), +}; + +static final CoordRec[] char42_stroke1 = { + new CoordRec( (float) 6.96, (float) 57.1429 ), + new CoordRec( (float) 54.579, (float) 28.5714 ), +}; + +static final CoordRec[] char42_stroke2 = { + new CoordRec( (float) 54.579, (float) 57.1429 ), + new CoordRec( (float) 6.96, (float) 28.5714 ), +}; + +static final StrokeRec char42[] = { + new StrokeRec(2, char42_stroke0), + new StrokeRec(2, char42_stroke1), + new StrokeRec(2, char42_stroke2), +}; + +/* char: 43 '+' */ + +static final CoordRec[] char43_stroke0 = { + new CoordRec( (float) 48.8371, (float) 85.7143 ), + new CoordRec( (float) 48.8371, (float) 0 ), +}; + +static final CoordRec[] char43_stroke1 = { + new CoordRec( (float) 5.98, (float) 42.8571 ), + new CoordRec( (float) 91.6943, (float) 42.8571 ), +}; + +static final StrokeRec char43[] = { + new StrokeRec(2, char43_stroke0), + new StrokeRec(2, char43_stroke1), +}; + +/* char: 44 ',' */ + +static final CoordRec[] char44_stroke0 = { + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 13.5219, (float) 0 ), + new CoordRec( (float) 8.76, (float) 4.7619 ), + new CoordRec( (float) 13.5219, (float) 9.5238 ), + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 18.2838, (float) -4.7619 ), + new CoordRec( (float) 13.5219, (float) -14.2857 ), + new CoordRec( (float) 8.76, (float) -19.0476 ), +}; + +static final StrokeRec char44[] = { + new StrokeRec(8, char44_stroke0), +}; + +/* char: 45 '-' */ + +static final CoordRec[] char45_stroke0 = { + new CoordRec( (float) 7.38, (float) 42.8571 ), + new CoordRec( (float) 93.0943, (float) 42.8571 ), +}; + +static final StrokeRec char45[] = { + new StrokeRec(2, char45_stroke0), +}; + +/* char: 46 '.' */ + +static final CoordRec[] char46_stroke0 = { + new CoordRec( (float) 13.1019, (float) 9.5238 ), + new CoordRec( (float) 8.34, (float) 4.7619 ), + new CoordRec( (float) 13.1019, (float) 0 ), + new CoordRec( (float) 17.8638, (float) 4.7619 ), + new CoordRec( (float) 13.1019, (float) 9.5238 ), +}; + +static final StrokeRec char46[] = { + new StrokeRec(5, char46_stroke0), +}; + +/* char: 47 '/' */ + +static final CoordRec[] char47_stroke0 = { + new CoordRec( (float) 7.24, (float) -14.2857 ), + new CoordRec( (float) 73.9067, (float) 100 ), +}; + +static final StrokeRec char47[] = { + new StrokeRec(2, char47_stroke0), +}; + +/* char: 48 '0' */ + +static final CoordRec[] char48_stroke0 = { + new CoordRec( (float) 33.5514, (float) 100 ), + new CoordRec( (float) 19.2657, (float) 95.2381 ), + new CoordRec( (float) 9.7419, (float) 80.9524 ), + new CoordRec( (float) 4.98, (float) 57.1429 ), + new CoordRec( (float) 4.98, (float) 42.8571 ), + new CoordRec( (float) 9.7419, (float) 19.0476 ), + new CoordRec( (float) 19.2657, (float) 4.7619 ), + new CoordRec( (float) 33.5514, (float) 0 ), + new CoordRec( (float) 43.0752, (float) 0 ), + new CoordRec( (float) 57.361, (float) 4.7619 ), + new CoordRec( (float) 66.8848, (float) 19.0476 ), + new CoordRec( (float) 71.6467, (float) 42.8571 ), + new CoordRec( (float) 71.6467, (float) 57.1429 ), + new CoordRec( (float) 66.8848, (float) 80.9524 ), + new CoordRec( (float) 57.361, (float) 95.2381 ), + new CoordRec( (float) 43.0752, (float) 100 ), + new CoordRec( (float) 33.5514, (float) 100 ), +}; + +static final StrokeRec char48[] = { + new StrokeRec(17, char48_stroke0), +}; + +/* char: 49 '1' */ + +static final CoordRec[] char49_stroke0 = { + new CoordRec( (float) 11.82, (float) 80.9524 ), + new CoordRec( (float) 21.3438, (float) 85.7143 ), + new CoordRec( (float) 35.6295, (float) 100 ), + new CoordRec( (float) 35.6295, (float) 0 ), +}; + +static final StrokeRec char49[] = { + new StrokeRec(4, char49_stroke0), +}; + +/* char: 50 '2' */ + +static final CoordRec[] char50_stroke0 = { + new CoordRec( (float) 10.1819, (float) 76.1905 ), + new CoordRec( (float) 10.1819, (float) 80.9524 ), + new CoordRec( (float) 14.9438, (float) 90.4762 ), + new CoordRec( (float) 19.7057, (float) 95.2381 ), + new CoordRec( (float) 29.2295, (float) 100 ), + new CoordRec( (float) 48.2771, (float) 100 ), + new CoordRec( (float) 57.801, (float) 95.2381 ), + new CoordRec( (float) 62.5629, (float) 90.4762 ), + new CoordRec( (float) 67.3248, (float) 80.9524 ), + new CoordRec( (float) 67.3248, (float) 71.4286 ), + new CoordRec( (float) 62.5629, (float) 61.9048 ), + new CoordRec( (float) 53.039, (float) 47.619 ), + new CoordRec( (float) 5.42, (float) 0 ), + new CoordRec( (float) 72.0867, (float) 0 ), +}; + +static final StrokeRec char50[] = { + new StrokeRec(14, char50_stroke0), +}; + +/* char: 51 '3' */ + +static final CoordRec[] char51_stroke0 = { + new CoordRec( (float) 14.5238, (float) 100 ), + new CoordRec( (float) 66.9048, (float) 100 ), + new CoordRec( (float) 38.3333, (float) 61.9048 ), + new CoordRec( (float) 52.619, (float) 61.9048 ), + new CoordRec( (float) 62.1429, (float) 57.1429 ), + new CoordRec( (float) 66.9048, (float) 52.381 ), + new CoordRec( (float) 71.6667, (float) 38.0952 ), + new CoordRec( (float) 71.6667, (float) 28.5714 ), + new CoordRec( (float) 66.9048, (float) 14.2857 ), + new CoordRec( (float) 57.381, (float) 4.7619 ), + new CoordRec( (float) 43.0952, (float) 0 ), + new CoordRec( (float) 28.8095, (float) 0 ), + new CoordRec( (float) 14.5238, (float) 4.7619 ), + new CoordRec( (float) 9.7619, (float) 9.5238 ), + new CoordRec( (float) 5, (float) 19.0476 ), +}; + +static final StrokeRec char51[] = { + new StrokeRec(15, char51_stroke0), +}; + +/* char: 52 '4' */ + +static final CoordRec[] char52_stroke0 = { + new CoordRec( (float) 51.499, (float) 100 ), + new CoordRec( (float) 3.88, (float) 33.3333 ), + new CoordRec( (float) 75.3086, (float) 33.3333 ), +}; + +static final CoordRec[] char52_stroke1 = { + new CoordRec( (float) 51.499, (float) 100 ), + new CoordRec( (float) 51.499, (float) 0 ), +}; + +static final StrokeRec char52[] = { + new StrokeRec(3, char52_stroke0), + new StrokeRec(2, char52_stroke1), +}; + +/* char: 53 '5' */ + +static final CoordRec[] char53_stroke0 = { + new CoordRec( (float) 62.0029, (float) 100 ), + new CoordRec( (float) 14.3838, (float) 100 ), + new CoordRec( (float) 9.6219, (float) 57.1429 ), + new CoordRec( (float) 14.3838, (float) 61.9048 ), + new CoordRec( (float) 28.6695, (float) 66.6667 ), + new CoordRec( (float) 42.9552, (float) 66.6667 ), + new CoordRec( (float) 57.241, (float) 61.9048 ), + new CoordRec( (float) 66.7648, (float) 52.381 ), + new CoordRec( (float) 71.5267, (float) 38.0952 ), + new CoordRec( (float) 71.5267, (float) 28.5714 ), + new CoordRec( (float) 66.7648, (float) 14.2857 ), + new CoordRec( (float) 57.241, (float) 4.7619 ), + new CoordRec( (float) 42.9552, (float) 0 ), + new CoordRec( (float) 28.6695, (float) 0 ), + new CoordRec( (float) 14.3838, (float) 4.7619 ), + new CoordRec( (float) 9.6219, (float) 9.5238 ), + new CoordRec( (float) 4.86, (float) 19.0476 ), +}; + +static final StrokeRec char53[] = { + new StrokeRec(17, char53_stroke0), +}; + +/* char: 54 '6' */ + +static final CoordRec[] char54_stroke0 = { + new CoordRec( (float) 62.7229, (float) 85.7143 ), + new CoordRec( (float) 57.961, (float) 95.2381 ), + new CoordRec( (float) 43.6752, (float) 100 ), + new CoordRec( (float) 34.1514, (float) 100 ), + new CoordRec( (float) 19.8657, (float) 95.2381 ), + new CoordRec( (float) 10.3419, (float) 80.9524 ), + new CoordRec( (float) 5.58, (float) 57.1429 ), + new CoordRec( (float) 5.58, (float) 33.3333 ), + new CoordRec( (float) 10.3419, (float) 14.2857 ), + new CoordRec( (float) 19.8657, (float) 4.7619 ), + new CoordRec( (float) 34.1514, (float) 0 ), + new CoordRec( (float) 38.9133, (float) 0 ), + new CoordRec( (float) 53.199, (float) 4.7619 ), + new CoordRec( (float) 62.7229, (float) 14.2857 ), + new CoordRec( (float) 67.4848, (float) 28.5714 ), + new CoordRec( (float) 67.4848, (float) 33.3333 ), + new CoordRec( (float) 62.7229, (float) 47.619 ), + new CoordRec( (float) 53.199, (float) 57.1429 ), + new CoordRec( (float) 38.9133, (float) 61.9048 ), + new CoordRec( (float) 34.1514, (float) 61.9048 ), + new CoordRec( (float) 19.8657, (float) 57.1429 ), + new CoordRec( (float) 10.3419, (float) 47.619 ), + new CoordRec( (float) 5.58, (float) 33.3333 ), +}; + +static final StrokeRec char54[] = { + new StrokeRec(23, char54_stroke0), +}; + +/* char: 55 '7' */ + +static final CoordRec[] char55_stroke0 = { + new CoordRec( (float) 72.2267, (float) 100 ), + new CoordRec( (float) 24.6076, (float) 0 ), +}; + +static final CoordRec[] char55_stroke1 = { + new CoordRec( (float) 5.56, (float) 100 ), + new CoordRec( (float) 72.2267, (float) 100 ), +}; + +static final StrokeRec char55[] = { + new StrokeRec(2, char55_stroke0), + new StrokeRec(2, char55_stroke1), +}; + +/* char: 56 '8' */ + +static final CoordRec[] char56_stroke0 = { + new CoordRec( (float) 29.4095, (float) 100 ), + new CoordRec( (float) 15.1238, (float) 95.2381 ), + new CoordRec( (float) 10.3619, (float) 85.7143 ), + new CoordRec( (float) 10.3619, (float) 76.1905 ), + new CoordRec( (float) 15.1238, (float) 66.6667 ), + new CoordRec( (float) 24.6476, (float) 61.9048 ), + new CoordRec( (float) 43.6952, (float) 57.1429 ), + new CoordRec( (float) 57.981, (float) 52.381 ), + new CoordRec( (float) 67.5048, (float) 42.8571 ), + new CoordRec( (float) 72.2667, (float) 33.3333 ), + new CoordRec( (float) 72.2667, (float) 19.0476 ), + new CoordRec( (float) 67.5048, (float) 9.5238 ), + new CoordRec( (float) 62.7429, (float) 4.7619 ), + new CoordRec( (float) 48.4571, (float) 0 ), + new CoordRec( (float) 29.4095, (float) 0 ), + new CoordRec( (float) 15.1238, (float) 4.7619 ), + new CoordRec( (float) 10.3619, (float) 9.5238 ), + new CoordRec( (float) 5.6, (float) 19.0476 ), + new CoordRec( (float) 5.6, (float) 33.3333 ), + new CoordRec( (float) 10.3619, (float) 42.8571 ), + new CoordRec( (float) 19.8857, (float) 52.381 ), + new CoordRec( (float) 34.1714, (float) 57.1429 ), + new CoordRec( (float) 53.219, (float) 61.9048 ), + new CoordRec( (float) 62.7429, (float) 66.6667 ), + new CoordRec( (float) 67.5048, (float) 76.1905 ), + new CoordRec( (float) 67.5048, (float) 85.7143 ), + new CoordRec( (float) 62.7429, (float) 95.2381 ), + new CoordRec( (float) 48.4571, (float) 100 ), + new CoordRec( (float) 29.4095, (float) 100 ), +}; + +static final StrokeRec char56[] = { + new StrokeRec(29, char56_stroke0), +}; + +/* char: 57 '9' */ + +static final CoordRec[] char57_stroke0 = { + new CoordRec( (float) 68.5048, (float) 66.6667 ), + new CoordRec( (float) 63.7429, (float) 52.381 ), + new CoordRec( (float) 54.219, (float) 42.8571 ), + new CoordRec( (float) 39.9333, (float) 38.0952 ), + new CoordRec( (float) 35.1714, (float) 38.0952 ), + new CoordRec( (float) 20.8857, (float) 42.8571 ), + new CoordRec( (float) 11.3619, (float) 52.381 ), + new CoordRec( (float) 6.6, (float) 66.6667 ), + new CoordRec( (float) 6.6, (float) 71.4286 ), + new CoordRec( (float) 11.3619, (float) 85.7143 ), + new CoordRec( (float) 20.8857, (float) 95.2381 ), + new CoordRec( (float) 35.1714, (float) 100 ), + new CoordRec( (float) 39.9333, (float) 100 ), + new CoordRec( (float) 54.219, (float) 95.2381 ), + new CoordRec( (float) 63.7429, (float) 85.7143 ), + new CoordRec( (float) 68.5048, (float) 66.6667 ), + new CoordRec( (float) 68.5048, (float) 42.8571 ), + new CoordRec( (float) 63.7429, (float) 19.0476 ), + new CoordRec( (float) 54.219, (float) 4.7619 ), + new CoordRec( (float) 39.9333, (float) 0 ), + new CoordRec( (float) 30.4095, (float) 0 ), + new CoordRec( (float) 16.1238, (float) 4.7619 ), + new CoordRec( (float) 11.3619, (float) 14.2857 ), +}; + +static final StrokeRec char57[] = { + new StrokeRec(23, char57_stroke0), +}; + +/* char: 58 ':' */ + +static final CoordRec[] char58_stroke0 = { + new CoordRec( (float) 14.0819, (float) 66.6667 ), + new CoordRec( (float) 9.32, (float) 61.9048 ), + new CoordRec( (float) 14.0819, (float) 57.1429 ), + new CoordRec( (float) 18.8438, (float) 61.9048 ), + new CoordRec( (float) 14.0819, (float) 66.6667 ), +}; + +static final CoordRec[] char58_stroke1 = { + new CoordRec( (float) 14.0819, (float) 9.5238 ), + new CoordRec( (float) 9.32, (float) 4.7619 ), + new CoordRec( (float) 14.0819, (float) 0 ), + new CoordRec( (float) 18.8438, (float) 4.7619 ), + new CoordRec( (float) 14.0819, (float) 9.5238 ), +}; + +static final StrokeRec char58[] = { + new StrokeRec(5, char58_stroke0), + new StrokeRec(5, char58_stroke1), +}; + +/* char: 59 ';' */ + +static final CoordRec[] char59_stroke0 = { + new CoordRec( (float) 12.9619, (float) 66.6667 ), + new CoordRec( (float) 8.2, (float) 61.9048 ), + new CoordRec( (float) 12.9619, (float) 57.1429 ), + new CoordRec( (float) 17.7238, (float) 61.9048 ), + new CoordRec( (float) 12.9619, (float) 66.6667 ), +}; + +static final CoordRec[] char59_stroke1 = { + new CoordRec( (float) 17.7238, (float) 4.7619 ), + new CoordRec( (float) 12.9619, (float) 0 ), + new CoordRec( (float) 8.2, (float) 4.7619 ), + new CoordRec( (float) 12.9619, (float) 9.5238 ), + new CoordRec( (float) 17.7238, (float) 4.7619 ), + new CoordRec( (float) 17.7238, (float) -4.7619 ), + new CoordRec( (float) 12.9619, (float) -14.2857 ), + new CoordRec( (float) 8.2, (float) -19.0476 ), +}; + +static final StrokeRec char59[] = { + new StrokeRec(5, char59_stroke0), + new StrokeRec(8, char59_stroke1), +}; + +/* char: 60 '<' */ + +static final CoordRec[] char60_stroke0 = { + new CoordRec( (float) 79.2505, (float) 85.7143 ), + new CoordRec( (float) 3.06, (float) 42.8571 ), + new CoordRec( (float) 79.2505, (float) 0 ), +}; + +static final StrokeRec char60[] = { + new StrokeRec(3, char60_stroke0), +}; + +/* char: 61 '=' */ + +static final CoordRec[] char61_stroke0 = { + new CoordRec( (float) 5.7, (float) 57.1429 ), + new CoordRec( (float) 91.4143, (float) 57.1429 ), +}; + +static final CoordRec[] char61_stroke1 = { + new CoordRec( (float) 5.7, (float) 28.5714 ), + new CoordRec( (float) 91.4143, (float) 28.5714 ), +}; + +static final StrokeRec char61[] = { + new StrokeRec(2, char61_stroke0), + new StrokeRec(2, char61_stroke1), +}; + +/* char: 62 '>' */ + +static final CoordRec[] char62_stroke0 = { + new CoordRec( (float) 2.78, (float) 85.7143 ), + new CoordRec( (float) 78.9705, (float) 42.8571 ), + new CoordRec( (float) 2.78, (float) 0 ), +}; + +static final StrokeRec char62[] = { + new StrokeRec(3, char62_stroke0), +}; + +/* char: 63 '?' */ + +static final CoordRec[] char63_stroke0 = { + new CoordRec( (float) 8.42, (float) 76.1905 ), + new CoordRec( (float) 8.42, (float) 80.9524 ), + new CoordRec( (float) 13.1819, (float) 90.4762 ), + new CoordRec( (float) 17.9438, (float) 95.2381 ), + new CoordRec( (float) 27.4676, (float) 100 ), + new CoordRec( (float) 46.5152, (float) 100 ), + new CoordRec( (float) 56.039, (float) 95.2381 ), + new CoordRec( (float) 60.801, (float) 90.4762 ), + new CoordRec( (float) 65.5629, (float) 80.9524 ), + new CoordRec( (float) 65.5629, (float) 71.4286 ), + new CoordRec( (float) 60.801, (float) 61.9048 ), + new CoordRec( (float) 56.039, (float) 57.1429 ), + new CoordRec( (float) 36.9914, (float) 47.619 ), + new CoordRec( (float) 36.9914, (float) 33.3333 ), +}; + +static final CoordRec[] char63_stroke1 = { + new CoordRec( (float) 36.9914, (float) 9.5238 ), + new CoordRec( (float) 32.2295, (float) 4.7619 ), + new CoordRec( (float) 36.9914, (float) 0 ), + new CoordRec( (float) 41.7533, (float) 4.7619 ), + new CoordRec( (float) 36.9914, (float) 9.5238 ), +}; + +static final StrokeRec char63[] = { + new StrokeRec(14, char63_stroke0), + new StrokeRec(5, char63_stroke1), +}; + +/* char: 64 '@' */ + +static final CoordRec[] char64_stroke0 = { + new CoordRec( (float) 49.2171, (float) 52.381 ), + new CoordRec( (float) 39.6933, (float) 57.1429 ), + new CoordRec( (float) 30.1695, (float) 57.1429 ), + new CoordRec( (float) 25.4076, (float) 47.619 ), + new CoordRec( (float) 25.4076, (float) 42.8571 ), + new CoordRec( (float) 30.1695, (float) 33.3333 ), + new CoordRec( (float) 39.6933, (float) 33.3333 ), + new CoordRec( (float) 49.2171, (float) 38.0952 ), +}; + +static final CoordRec[] char64_stroke1 = { + new CoordRec( (float) 49.2171, (float) 57.1429 ), + new CoordRec( (float) 49.2171, (float) 38.0952 ), + new CoordRec( (float) 53.979, (float) 33.3333 ), + new CoordRec( (float) 63.5029, (float) 33.3333 ), + new CoordRec( (float) 68.2648, (float) 42.8571 ), + new CoordRec( (float) 68.2648, (float) 47.619 ), + new CoordRec( (float) 63.5029, (float) 61.9048 ), + new CoordRec( (float) 53.979, (float) 71.4286 ), + new CoordRec( (float) 39.6933, (float) 76.1905 ), + new CoordRec( (float) 34.9314, (float) 76.1905 ), + new CoordRec( (float) 20.6457, (float) 71.4286 ), + new CoordRec( (float) 11.1219, (float) 61.9048 ), + new CoordRec( (float) 6.36, (float) 47.619 ), + new CoordRec( (float) 6.36, (float) 42.8571 ), + new CoordRec( (float) 11.1219, (float) 28.5714 ), + new CoordRec( (float) 20.6457, (float) 19.0476 ), + new CoordRec( (float) 34.9314, (float) 14.2857 ), + new CoordRec( (float) 39.6933, (float) 14.2857 ), + new CoordRec( (float) 53.979, (float) 19.0476 ), +}; + +static final StrokeRec char64[] = { + new StrokeRec(8, char64_stroke0), + new StrokeRec(19, char64_stroke1), +}; + +/* char: 65 'A' */ + +static final CoordRec[] char65_stroke0 = { + new CoordRec( (float) 40.5952, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final CoordRec[] char65_stroke1 = { + new CoordRec( (float) 40.5952, (float) 100 ), + new CoordRec( (float) 78.6905, (float) 0 ), +}; + +static final CoordRec[] char65_stroke2 = { + new CoordRec( (float) 16.7857, (float) 33.3333 ), + new CoordRec( (float) 64.4048, (float) 33.3333 ), +}; + +static final StrokeRec char65[] = { + new StrokeRec(2, char65_stroke0), + new StrokeRec(2, char65_stroke1), + new StrokeRec(2, char65_stroke2), +}; + +/* char: 66 'B' */ + +static final CoordRec[] char66_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char66_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 54.2771, (float) 100 ), + new CoordRec( (float) 68.5629, (float) 95.2381 ), + new CoordRec( (float) 73.3248, (float) 90.4762 ), + new CoordRec( (float) 78.0867, (float) 80.9524 ), + new CoordRec( (float) 78.0867, (float) 71.4286 ), + new CoordRec( (float) 73.3248, (float) 61.9048 ), + new CoordRec( (float) 68.5629, (float) 57.1429 ), + new CoordRec( (float) 54.2771, (float) 52.381 ), +}; + +static final CoordRec[] char66_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 54.2771, (float) 52.381 ), + new CoordRec( (float) 68.5629, (float) 47.619 ), + new CoordRec( (float) 73.3248, (float) 42.8571 ), + new CoordRec( (float) 78.0867, (float) 33.3333 ), + new CoordRec( (float) 78.0867, (float) 19.0476 ), + new CoordRec( (float) 73.3248, (float) 9.5238 ), + new CoordRec( (float) 68.5629, (float) 4.7619 ), + new CoordRec( (float) 54.2771, (float) 0 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final StrokeRec char66[] = { + new StrokeRec(2, char66_stroke0), + new StrokeRec(9, char66_stroke1), + new StrokeRec(10, char66_stroke2), +}; + +/* char: 67 'C' */ + +static final CoordRec[] char67_stroke0 = { + new CoordRec( (float) 78.0886, (float) 76.1905 ), + new CoordRec( (float) 73.3267, (float) 85.7143 ), + new CoordRec( (float) 63.8029, (float) 95.2381 ), + new CoordRec( (float) 54.279, (float) 100 ), + new CoordRec( (float) 35.2314, (float) 100 ), + new CoordRec( (float) 25.7076, (float) 95.2381 ), + new CoordRec( (float) 16.1838, (float) 85.7143 ), + new CoordRec( (float) 11.4219, (float) 76.1905 ), + new CoordRec( (float) 6.66, (float) 61.9048 ), + new CoordRec( (float) 6.66, (float) 38.0952 ), + new CoordRec( (float) 11.4219, (float) 23.8095 ), + new CoordRec( (float) 16.1838, (float) 14.2857 ), + new CoordRec( (float) 25.7076, (float) 4.7619 ), + new CoordRec( (float) 35.2314, (float) 0 ), + new CoordRec( (float) 54.279, (float) 0 ), + new CoordRec( (float) 63.8029, (float) 4.7619 ), + new CoordRec( (float) 73.3267, (float) 14.2857 ), + new CoordRec( (float) 78.0886, (float) 23.8095 ), +}; + +static final StrokeRec char67[] = { + new StrokeRec(18, char67_stroke0), +}; + +/* char: 68 'D' */ + +static final CoordRec[] char68_stroke0 = { + new CoordRec( (float) 11.96, (float) 100 ), + new CoordRec( (float) 11.96, (float) 0 ), +}; + +static final CoordRec[] char68_stroke1 = { + new CoordRec( (float) 11.96, (float) 100 ), + new CoordRec( (float) 45.2933, (float) 100 ), + new CoordRec( (float) 59.579, (float) 95.2381 ), + new CoordRec( (float) 69.1029, (float) 85.7143 ), + new CoordRec( (float) 73.8648, (float) 76.1905 ), + new CoordRec( (float) 78.6267, (float) 61.9048 ), + new CoordRec( (float) 78.6267, (float) 38.0952 ), + new CoordRec( (float) 73.8648, (float) 23.8095 ), + new CoordRec( (float) 69.1029, (float) 14.2857 ), + new CoordRec( (float) 59.579, (float) 4.7619 ), + new CoordRec( (float) 45.2933, (float) 0 ), + new CoordRec( (float) 11.96, (float) 0 ), +}; + +static final StrokeRec char68[] = { + new StrokeRec(2, char68_stroke0), + new StrokeRec(12, char68_stroke1), +}; + +/* char: 69 'E' */ + +static final CoordRec[] char69_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char69_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 73.3248, (float) 100 ), +}; + +static final CoordRec[] char69_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 49.5152, (float) 52.381 ), +}; + +static final CoordRec[] char69_stroke3 = { + new CoordRec( (float) 11.42, (float) 0 ), + new CoordRec( (float) 73.3248, (float) 0 ), +}; + +static final StrokeRec char69[] = { + new StrokeRec(2, char69_stroke0), + new StrokeRec(2, char69_stroke1), + new StrokeRec(2, char69_stroke2), + new StrokeRec(2, char69_stroke3), +}; + +/* char: 70 'F' */ + +static final CoordRec[] char70_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char70_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 73.3248, (float) 100 ), +}; + +static final CoordRec[] char70_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 49.5152, (float) 52.381 ), +}; + +static final StrokeRec char70[] = { + new StrokeRec(2, char70_stroke0), + new StrokeRec(2, char70_stroke1), + new StrokeRec(2, char70_stroke2), +}; + +/* char: 71 'G' */ + +static final CoordRec[] char71_stroke0 = { + new CoordRec( (float) 78.4886, (float) 76.1905 ), + new CoordRec( (float) 73.7267, (float) 85.7143 ), + new CoordRec( (float) 64.2029, (float) 95.2381 ), + new CoordRec( (float) 54.679, (float) 100 ), + new CoordRec( (float) 35.6314, (float) 100 ), + new CoordRec( (float) 26.1076, (float) 95.2381 ), + new CoordRec( (float) 16.5838, (float) 85.7143 ), + new CoordRec( (float) 11.8219, (float) 76.1905 ), + new CoordRec( (float) 7.06, (float) 61.9048 ), + new CoordRec( (float) 7.06, (float) 38.0952 ), + new CoordRec( (float) 11.8219, (float) 23.8095 ), + new CoordRec( (float) 16.5838, (float) 14.2857 ), + new CoordRec( (float) 26.1076, (float) 4.7619 ), + new CoordRec( (float) 35.6314, (float) 0 ), + new CoordRec( (float) 54.679, (float) 0 ), + new CoordRec( (float) 64.2029, (float) 4.7619 ), + new CoordRec( (float) 73.7267, (float) 14.2857 ), + new CoordRec( (float) 78.4886, (float) 23.8095 ), + new CoordRec( (float) 78.4886, (float) 38.0952 ), +}; + +static final CoordRec[] char71_stroke1 = { + new CoordRec( (float) 54.679, (float) 38.0952 ), + new CoordRec( (float) 78.4886, (float) 38.0952 ), +}; + +static final StrokeRec char71[] = { + new StrokeRec(19, char71_stroke0), + new StrokeRec(2, char71_stroke1), +}; + +/* char: 72 'H' */ + +static final CoordRec[] char72_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char72_stroke1 = { + new CoordRec( (float) 78.0867, (float) 100 ), + new CoordRec( (float) 78.0867, (float) 0 ), +}; + +static final CoordRec[] char72_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 78.0867, (float) 52.381 ), +}; + +static final StrokeRec char72[] = { + new StrokeRec(2, char72_stroke0), + new StrokeRec(2, char72_stroke1), + new StrokeRec(2, char72_stroke2), +}; + +/* char: 73 'I' */ + +static final CoordRec[] char73_stroke0 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 10.86, (float) 0 ), +}; + +static final StrokeRec char73[] = { + new StrokeRec(2, char73_stroke0), +}; + +/* char: 74 'J' */ + +static final CoordRec[] char74_stroke0 = { + new CoordRec( (float) 50.119, (float) 100 ), + new CoordRec( (float) 50.119, (float) 23.8095 ), + new CoordRec( (float) 45.3571, (float) 9.5238 ), + new CoordRec( (float) 40.5952, (float) 4.7619 ), + new CoordRec( (float) 31.0714, (float) 0 ), + new CoordRec( (float) 21.5476, (float) 0 ), + new CoordRec( (float) 12.0238, (float) 4.7619 ), + new CoordRec( (float) 7.2619, (float) 9.5238 ), + new CoordRec( (float) 2.5, (float) 23.8095 ), + new CoordRec( (float) 2.5, (float) 33.3333 ), +}; + +static final StrokeRec char74[] = { + new StrokeRec(10, char74_stroke0), +}; + +/* char: 75 'K' */ + +static final CoordRec[] char75_stroke0 = { + new CoordRec( (float) 11.28, (float) 100 ), + new CoordRec( (float) 11.28, (float) 0 ), +}; + +static final CoordRec[] char75_stroke1 = { + new CoordRec( (float) 77.9467, (float) 100 ), + new CoordRec( (float) 11.28, (float) 33.3333 ), +}; + +static final CoordRec[] char75_stroke2 = { + new CoordRec( (float) 35.0895, (float) 57.1429 ), + new CoordRec( (float) 77.9467, (float) 0 ), +}; + +static final StrokeRec char75[] = { + new StrokeRec(2, char75_stroke0), + new StrokeRec(2, char75_stroke1), + new StrokeRec(2, char75_stroke2), +}; + +/* char: 76 'L' */ + +static final CoordRec[] char76_stroke0 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 11.68, (float) 0 ), +}; + +static final CoordRec[] char76_stroke1 = { + new CoordRec( (float) 11.68, (float) 0 ), + new CoordRec( (float) 68.8229, (float) 0 ), +}; + +static final StrokeRec char76[] = { + new StrokeRec(2, char76_stroke0), + new StrokeRec(2, char76_stroke1), +}; + +/* char: 77 'M' */ + +static final CoordRec[] char77_stroke0 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 10.86, (float) 0 ), +}; + +static final CoordRec[] char77_stroke1 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 48.9552, (float) 0 ), +}; + +static final CoordRec[] char77_stroke2 = { + new CoordRec( (float) 87.0505, (float) 100 ), + new CoordRec( (float) 48.9552, (float) 0 ), +}; + +static final CoordRec[] char77_stroke3 = { + new CoordRec( (float) 87.0505, (float) 100 ), + new CoordRec( (float) 87.0505, (float) 0 ), +}; + +static final StrokeRec char77[] = { + new StrokeRec(2, char77_stroke0), + new StrokeRec(2, char77_stroke1), + new StrokeRec(2, char77_stroke2), + new StrokeRec(2, char77_stroke3), +}; + +/* char: 78 'N' */ + +static final CoordRec[] char78_stroke0 = { + new CoordRec( (float) 11.14, (float) 100 ), + new CoordRec( (float) 11.14, (float) 0 ), +}; + +static final CoordRec[] char78_stroke1 = { + new CoordRec( (float) 11.14, (float) 100 ), + new CoordRec( (float) 77.8067, (float) 0 ), +}; + +static final CoordRec[] char78_stroke2 = { + new CoordRec( (float) 77.8067, (float) 100 ), + new CoordRec( (float) 77.8067, (float) 0 ), +}; + +static final StrokeRec char78[] = { + new StrokeRec(2, char78_stroke0), + new StrokeRec(2, char78_stroke1), + new StrokeRec(2, char78_stroke2), +}; + +/* char: 79 'O' */ + +static final CoordRec[] char79_stroke0 = { + new CoordRec( (float) 34.8114, (float) 100 ), + new CoordRec( (float) 25.2876, (float) 95.2381 ), + new CoordRec( (float) 15.7638, (float) 85.7143 ), + new CoordRec( (float) 11.0019, (float) 76.1905 ), + new CoordRec( (float) 6.24, (float) 61.9048 ), + new CoordRec( (float) 6.24, (float) 38.0952 ), + new CoordRec( (float) 11.0019, (float) 23.8095 ), + new CoordRec( (float) 15.7638, (float) 14.2857 ), + new CoordRec( (float) 25.2876, (float) 4.7619 ), + new CoordRec( (float) 34.8114, (float) 0 ), + new CoordRec( (float) 53.859, (float) 0 ), + new CoordRec( (float) 63.3829, (float) 4.7619 ), + new CoordRec( (float) 72.9067, (float) 14.2857 ), + new CoordRec( (float) 77.6686, (float) 23.8095 ), + new CoordRec( (float) 82.4305, (float) 38.0952 ), + new CoordRec( (float) 82.4305, (float) 61.9048 ), + new CoordRec( (float) 77.6686, (float) 76.1905 ), + new CoordRec( (float) 72.9067, (float) 85.7143 ), + new CoordRec( (float) 63.3829, (float) 95.2381 ), + new CoordRec( (float) 53.859, (float) 100 ), + new CoordRec( (float) 34.8114, (float) 100 ), +}; + +static final StrokeRec char79[] = { + new StrokeRec(21, char79_stroke0), +}; + +/* char: 80 'P' */ + +static final CoordRec[] char80_stroke0 = { + new CoordRec( (float) 12.1, (float) 100 ), + new CoordRec( (float) 12.1, (float) 0 ), +}; + +static final CoordRec[] char80_stroke1 = { + new CoordRec( (float) 12.1, (float) 100 ), + new CoordRec( (float) 54.9571, (float) 100 ), + new CoordRec( (float) 69.2429, (float) 95.2381 ), + new CoordRec( (float) 74.0048, (float) 90.4762 ), + new CoordRec( (float) 78.7667, (float) 80.9524 ), + new CoordRec( (float) 78.7667, (float) 66.6667 ), + new CoordRec( (float) 74.0048, (float) 57.1429 ), + new CoordRec( (float) 69.2429, (float) 52.381 ), + new CoordRec( (float) 54.9571, (float) 47.619 ), + new CoordRec( (float) 12.1, (float) 47.619 ), +}; + +static final StrokeRec char80[] = { + new StrokeRec(2, char80_stroke0), + new StrokeRec(10, char80_stroke1), +}; + +/* char: 81 'Q' */ + +static final CoordRec[] char81_stroke0 = { + new CoordRec( (float) 33.8714, (float) 100 ), + new CoordRec( (float) 24.3476, (float) 95.2381 ), + new CoordRec( (float) 14.8238, (float) 85.7143 ), + new CoordRec( (float) 10.0619, (float) 76.1905 ), + new CoordRec( (float) 5.3, (float) 61.9048 ), + new CoordRec( (float) 5.3, (float) 38.0952 ), + new CoordRec( (float) 10.0619, (float) 23.8095 ), + new CoordRec( (float) 14.8238, (float) 14.2857 ), + new CoordRec( (float) 24.3476, (float) 4.7619 ), + new CoordRec( (float) 33.8714, (float) 0 ), + new CoordRec( (float) 52.919, (float) 0 ), + new CoordRec( (float) 62.4429, (float) 4.7619 ), + new CoordRec( (float) 71.9667, (float) 14.2857 ), + new CoordRec( (float) 76.7286, (float) 23.8095 ), + new CoordRec( (float) 81.4905, (float) 38.0952 ), + new CoordRec( (float) 81.4905, (float) 61.9048 ), + new CoordRec( (float) 76.7286, (float) 76.1905 ), + new CoordRec( (float) 71.9667, (float) 85.7143 ), + new CoordRec( (float) 62.4429, (float) 95.2381 ), + new CoordRec( (float) 52.919, (float) 100 ), + new CoordRec( (float) 33.8714, (float) 100 ), +}; + +static final CoordRec[] char81_stroke1 = { + new CoordRec( (float) 48.1571, (float) 19.0476 ), + new CoordRec( (float) 76.7286, (float) -9.5238 ), +}; + +static final StrokeRec char81[] = { + new StrokeRec(21, char81_stroke0), + new StrokeRec(2, char81_stroke1), +}; + +/* char: 82 'R' */ + +static final CoordRec[] char82_stroke0 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 11.68, (float) 0 ), +}; + +static final CoordRec[] char82_stroke1 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 54.5371, (float) 100 ), + new CoordRec( (float) 68.8229, (float) 95.2381 ), + new CoordRec( (float) 73.5848, (float) 90.4762 ), + new CoordRec( (float) 78.3467, (float) 80.9524 ), + new CoordRec( (float) 78.3467, (float) 71.4286 ), + new CoordRec( (float) 73.5848, (float) 61.9048 ), + new CoordRec( (float) 68.8229, (float) 57.1429 ), + new CoordRec( (float) 54.5371, (float) 52.381 ), + new CoordRec( (float) 11.68, (float) 52.381 ), +}; + +static final CoordRec[] char82_stroke2 = { + new CoordRec( (float) 45.0133, (float) 52.381 ), + new CoordRec( (float) 78.3467, (float) 0 ), +}; + +static final StrokeRec char82[] = { + new StrokeRec(2, char82_stroke0), + new StrokeRec(10, char82_stroke1), + new StrokeRec(2, char82_stroke2), +}; + +/* char: 83 'S' */ + +static final CoordRec[] char83_stroke0 = { + new CoordRec( (float) 74.6667, (float) 85.7143 ), + new CoordRec( (float) 65.1429, (float) 95.2381 ), + new CoordRec( (float) 50.8571, (float) 100 ), + new CoordRec( (float) 31.8095, (float) 100 ), + new CoordRec( (float) 17.5238, (float) 95.2381 ), + new CoordRec( (float) 8, (float) 85.7143 ), + new CoordRec( (float) 8, (float) 76.1905 ), + new CoordRec( (float) 12.7619, (float) 66.6667 ), + new CoordRec( (float) 17.5238, (float) 61.9048 ), + new CoordRec( (float) 27.0476, (float) 57.1429 ), + new CoordRec( (float) 55.619, (float) 47.619 ), + new CoordRec( (float) 65.1429, (float) 42.8571 ), + new CoordRec( (float) 69.9048, (float) 38.0952 ), + new CoordRec( (float) 74.6667, (float) 28.5714 ), + new CoordRec( (float) 74.6667, (float) 14.2857 ), + new CoordRec( (float) 65.1429, (float) 4.7619 ), + new CoordRec( (float) 50.8571, (float) 0 ), + new CoordRec( (float) 31.8095, (float) 0 ), + new CoordRec( (float) 17.5238, (float) 4.7619 ), + new CoordRec( (float) 8, (float) 14.2857 ), +}; + +static final StrokeRec char83[] = { + new StrokeRec(20, char83_stroke0), +}; + +/* char: 84 'T' */ + +static final CoordRec[] char84_stroke0 = { + new CoordRec( (float) 35.6933, (float) 100 ), + new CoordRec( (float) 35.6933, (float) 0 ), +}; + +static final CoordRec[] char84_stroke1 = { + new CoordRec( (float) 2.36, (float) 100 ), + new CoordRec( (float) 69.0267, (float) 100 ), +}; + +static final StrokeRec char84[] = { + new StrokeRec(2, char84_stroke0), + new StrokeRec(2, char84_stroke1), +}; + +/* char: 85 'U' */ + +static final CoordRec[] char85_stroke0 = { + new CoordRec( (float) 11.54, (float) 100 ), + new CoordRec( (float) 11.54, (float) 28.5714 ), + new CoordRec( (float) 16.3019, (float) 14.2857 ), + new CoordRec( (float) 25.8257, (float) 4.7619 ), + new CoordRec( (float) 40.1114, (float) 0 ), + new CoordRec( (float) 49.6352, (float) 0 ), + new CoordRec( (float) 63.921, (float) 4.7619 ), + new CoordRec( (float) 73.4448, (float) 14.2857 ), + new CoordRec( (float) 78.2067, (float) 28.5714 ), + new CoordRec( (float) 78.2067, (float) 100 ), +}; + +static final StrokeRec char85[] = { + new StrokeRec(10, char85_stroke0), +}; + +/* char: 86 'V' */ + +static final CoordRec[] char86_stroke0 = { + new CoordRec( (float) 2.36, (float) 100 ), + new CoordRec( (float) 40.4552, (float) 0 ), +}; + +static final CoordRec[] char86_stroke1 = { + new CoordRec( (float) 78.5505, (float) 100 ), + new CoordRec( (float) 40.4552, (float) 0 ), +}; + +static final StrokeRec char86[] = { + new StrokeRec(2, char86_stroke0), + new StrokeRec(2, char86_stroke1), +}; + +/* char: 87 'W' */ + +static final CoordRec[] char87_stroke0 = { + new CoordRec( (float) 2.22, (float) 100 ), + new CoordRec( (float) 26.0295, (float) 0 ), +}; + +static final CoordRec[] char87_stroke1 = { + new CoordRec( (float) 49.839, (float) 100 ), + new CoordRec( (float) 26.0295, (float) 0 ), +}; + +static final CoordRec[] char87_stroke2 = { + new CoordRec( (float) 49.839, (float) 100 ), + new CoordRec( (float) 73.6486, (float) 0 ), +}; + +static final CoordRec[] char87_stroke3 = { + new CoordRec( (float) 97.4581, (float) 100 ), + new CoordRec( (float) 73.6486, (float) 0 ), +}; + +static final StrokeRec char87[] = { + new StrokeRec(2, char87_stroke0), + new StrokeRec(2, char87_stroke1), + new StrokeRec(2, char87_stroke2), + new StrokeRec(2, char87_stroke3), +}; + +/* char: 88 'X' */ + +static final CoordRec[] char88_stroke0 = { + new CoordRec( (float) 2.5, (float) 100 ), + new CoordRec( (float) 69.1667, (float) 0 ), +}; + +static final CoordRec[] char88_stroke1 = { + new CoordRec( (float) 69.1667, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final StrokeRec char88[] = { + new StrokeRec(2, char88_stroke0), + new StrokeRec(2, char88_stroke1), +}; + +/* char: 89 'Y' */ + +static final CoordRec[] char89_stroke0 = { + new CoordRec( (float) 1.52, (float) 100 ), + new CoordRec( (float) 39.6152, (float) 52.381 ), + new CoordRec( (float) 39.6152, (float) 0 ), +}; + +static final CoordRec[] char89_stroke1 = { + new CoordRec( (float) 77.7105, (float) 100 ), + new CoordRec( (float) 39.6152, (float) 52.381 ), +}; + +static final StrokeRec char89[] = { + new StrokeRec(3, char89_stroke0), + new StrokeRec(2, char89_stroke1), +}; + +/* char: 90 'Z' */ + +static final CoordRec[] char90_stroke0 = { + new CoordRec( (float) 69.1667, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final CoordRec[] char90_stroke1 = { + new CoordRec( (float) 2.5, (float) 100 ), + new CoordRec( (float) 69.1667, (float) 100 ), +}; + +static final CoordRec[] char90_stroke2 = { + new CoordRec( (float) 2.5, (float) 0 ), + new CoordRec( (float) 69.1667, (float) 0 ), +}; + +static final StrokeRec char90[] = { + new StrokeRec(2, char90_stroke0), + new StrokeRec(2, char90_stroke1), + new StrokeRec(2, char90_stroke2), +}; + +/* char: 91 '[' */ + +static final CoordRec[] char91_stroke0 = { + new CoordRec( (float) 7.78, (float) 119.048 ), + new CoordRec( (float) 7.78, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke1 = { + new CoordRec( (float) 12.5419, (float) 119.048 ), + new CoordRec( (float) 12.5419, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke2 = { + new CoordRec( (float) 7.78, (float) 119.048 ), + new CoordRec( (float) 41.1133, (float) 119.048 ), +}; + +static final CoordRec[] char91_stroke3 = { + new CoordRec( (float) 7.78, (float) -33.3333 ), + new CoordRec( (float) 41.1133, (float) -33.3333 ), +}; + +static final StrokeRec char91[] = { + new StrokeRec(2, char91_stroke0), + new StrokeRec(2, char91_stroke1), + new StrokeRec(2, char91_stroke2), + new StrokeRec(2, char91_stroke3), +}; + +/* char: 92 '\' */ + +static final CoordRec[] char92_stroke0 = { + new CoordRec( (float) 5.84, (float) 100 ), + new CoordRec( (float) 72.5067, (float) -14.2857 ), +}; + +static final StrokeRec char92[] = { + new StrokeRec(2, char92_stroke0), +}; + +/* char: 93 ']' */ + +static final CoordRec[] char93_stroke0 = { + new CoordRec( (float) 33.0114, (float) 119.048 ), + new CoordRec( (float) 33.0114, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke1 = { + new CoordRec( (float) 37.7733, (float) 119.048 ), + new CoordRec( (float) 37.7733, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke2 = { + new CoordRec( (float) 4.44, (float) 119.048 ), + new CoordRec( (float) 37.7733, (float) 119.048 ), +}; + +static final CoordRec[] char93_stroke3 = { + new CoordRec( (float) 4.44, (float) -33.3333 ), + new CoordRec( (float) 37.7733, (float) -33.3333 ), +}; + +static final StrokeRec char93[] = { + new StrokeRec(2, char93_stroke0), + new StrokeRec(2, char93_stroke1), + new StrokeRec(2, char93_stroke2), + new StrokeRec(2, char93_stroke3), +}; + +/* char: 94 '^' */ + +static final CoordRec[] char94_stroke0 = { + new CoordRec( (float) 44.0752, (float) 109.524 ), + new CoordRec( (float) 5.98, (float) 42.8571 ), +}; + +static final CoordRec[] char94_stroke1 = { + new CoordRec( (float) 44.0752, (float) 109.524 ), + new CoordRec( (float) 82.1705, (float) 42.8571 ), +}; + +static final StrokeRec char94[] = { + new StrokeRec(2, char94_stroke0), + new StrokeRec(2, char94_stroke1), +}; + +/* char: 95 '_' */ + +static final CoordRec[] char95_stroke0 = { + new CoordRec( (float) -1.1, (float) -33.3333 ), + new CoordRec( (float) 103.662, (float) -33.3333 ), + new CoordRec( (float) 103.662, (float) -28.5714 ), + new CoordRec( (float) -1.1, (float) -28.5714 ), + new CoordRec( (float) -1.1, (float) -33.3333 ), +}; + +static final StrokeRec char95[] = { + new StrokeRec(5, char95_stroke0), +}; + +/* char: 96 '`' */ + +static final CoordRec[] char96_stroke0 = { + new CoordRec( (float) 33.0219, (float) 100 ), + new CoordRec( (float) 56.8314, (float) 71.4286 ), +}; + +static final CoordRec[] char96_stroke1 = { + new CoordRec( (float) 33.0219, (float) 100 ), + new CoordRec( (float) 28.26, (float) 95.2381 ), + new CoordRec( (float) 56.8314, (float) 71.4286 ), +}; + +static final StrokeRec char96[] = { + new StrokeRec(2, char96_stroke0), + new StrokeRec(3, char96_stroke1), +}; + +/* char: 97 'a' */ + +static final CoordRec[] char97_stroke0 = { + new CoordRec( (float) 63.8229, (float) 66.6667 ), + new CoordRec( (float) 63.8229, (float) 0 ), +}; + +static final CoordRec[] char97_stroke1 = { + new CoordRec( (float) 63.8229, (float) 52.381 ), + new CoordRec( (float) 54.299, (float) 61.9048 ), + new CoordRec( (float) 44.7752, (float) 66.6667 ), + new CoordRec( (float) 30.4895, (float) 66.6667 ), + new CoordRec( (float) 20.9657, (float) 61.9048 ), + new CoordRec( (float) 11.4419, (float) 52.381 ), + new CoordRec( (float) 6.68, (float) 38.0952 ), + new CoordRec( (float) 6.68, (float) 28.5714 ), + new CoordRec( (float) 11.4419, (float) 14.2857 ), + new CoordRec( (float) 20.9657, (float) 4.7619 ), + new CoordRec( (float) 30.4895, (float) 0 ), + new CoordRec( (float) 44.7752, (float) 0 ), + new CoordRec( (float) 54.299, (float) 4.7619 ), + new CoordRec( (float) 63.8229, (float) 14.2857 ), +}; + +static final StrokeRec char97[] = { + new StrokeRec(2, char97_stroke0), + new StrokeRec(14, char97_stroke1), +}; + +/* char: 98 'b' */ + +static final CoordRec[] char98_stroke0 = { + new CoordRec( (float) 8.76, (float) 100 ), + new CoordRec( (float) 8.76, (float) 0 ), +}; + +static final CoordRec[] char98_stroke1 = { + new CoordRec( (float) 8.76, (float) 52.381 ), + new CoordRec( (float) 18.2838, (float) 61.9048 ), + new CoordRec( (float) 27.8076, (float) 66.6667 ), + new CoordRec( (float) 42.0933, (float) 66.6667 ), + new CoordRec( (float) 51.6171, (float) 61.9048 ), + new CoordRec( (float) 61.141, (float) 52.381 ), + new CoordRec( (float) 65.9029, (float) 38.0952 ), + new CoordRec( (float) 65.9029, (float) 28.5714 ), + new CoordRec( (float) 61.141, (float) 14.2857 ), + new CoordRec( (float) 51.6171, (float) 4.7619 ), + new CoordRec( (float) 42.0933, (float) 0 ), + new CoordRec( (float) 27.8076, (float) 0 ), + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 8.76, (float) 14.2857 ), +}; + +static final StrokeRec char98[] = { + new StrokeRec(2, char98_stroke0), + new StrokeRec(14, char98_stroke1), +}; + +/* char: 99 'c' */ + +static final CoordRec[] char99_stroke0 = { + new CoordRec( (float) 62.6629, (float) 52.381 ), + new CoordRec( (float) 53.139, (float) 61.9048 ), + new CoordRec( (float) 43.6152, (float) 66.6667 ), + new CoordRec( (float) 29.3295, (float) 66.6667 ), + new CoordRec( (float) 19.8057, (float) 61.9048 ), + new CoordRec( (float) 10.2819, (float) 52.381 ), + new CoordRec( (float) 5.52, (float) 38.0952 ), + new CoordRec( (float) 5.52, (float) 28.5714 ), + new CoordRec( (float) 10.2819, (float) 14.2857 ), + new CoordRec( (float) 19.8057, (float) 4.7619 ), + new CoordRec( (float) 29.3295, (float) 0 ), + new CoordRec( (float) 43.6152, (float) 0 ), + new CoordRec( (float) 53.139, (float) 4.7619 ), + new CoordRec( (float) 62.6629, (float) 14.2857 ), +}; + +static final StrokeRec char99[] = { + new StrokeRec(14, char99_stroke0), +}; + +/* char: 100 'd' */ + +static final CoordRec[] char100_stroke0 = { + new CoordRec( (float) 61.7829, (float) 100 ), + new CoordRec( (float) 61.7829, (float) 0 ), +}; + +static final CoordRec[] char100_stroke1 = { + new CoordRec( (float) 61.7829, (float) 52.381 ), + new CoordRec( (float) 52.259, (float) 61.9048 ), + new CoordRec( (float) 42.7352, (float) 66.6667 ), + new CoordRec( (float) 28.4495, (float) 66.6667 ), + new CoordRec( (float) 18.9257, (float) 61.9048 ), + new CoordRec( (float) 9.4019, (float) 52.381 ), + new CoordRec( (float) 4.64, (float) 38.0952 ), + new CoordRec( (float) 4.64, (float) 28.5714 ), + new CoordRec( (float) 9.4019, (float) 14.2857 ), + new CoordRec( (float) 18.9257, (float) 4.7619 ), + new CoordRec( (float) 28.4495, (float) 0 ), + new CoordRec( (float) 42.7352, (float) 0 ), + new CoordRec( (float) 52.259, (float) 4.7619 ), + new CoordRec( (float) 61.7829, (float) 14.2857 ), +}; + +static final StrokeRec char100[] = { + new StrokeRec(2, char100_stroke0), + new StrokeRec(14, char100_stroke1), +}; + +/* char: 101 'e' */ + +static final CoordRec[] char101_stroke0 = { + new CoordRec( (float) 5.72, (float) 38.0952 ), + new CoordRec( (float) 62.8629, (float) 38.0952 ), + new CoordRec( (float) 62.8629, (float) 47.619 ), + new CoordRec( (float) 58.101, (float) 57.1429 ), + new CoordRec( (float) 53.339, (float) 61.9048 ), + new CoordRec( (float) 43.8152, (float) 66.6667 ), + new CoordRec( (float) 29.5295, (float) 66.6667 ), + new CoordRec( (float) 20.0057, (float) 61.9048 ), + new CoordRec( (float) 10.4819, (float) 52.381 ), + new CoordRec( (float) 5.72, (float) 38.0952 ), + new CoordRec( (float) 5.72, (float) 28.5714 ), + new CoordRec( (float) 10.4819, (float) 14.2857 ), + new CoordRec( (float) 20.0057, (float) 4.7619 ), + new CoordRec( (float) 29.5295, (float) 0 ), + new CoordRec( (float) 43.8152, (float) 0 ), + new CoordRec( (float) 53.339, (float) 4.7619 ), + new CoordRec( (float) 62.8629, (float) 14.2857 ), +}; + +static final StrokeRec char101[] = { + new StrokeRec(17, char101_stroke0), +}; + +/* char: 102 'f' */ + +static final CoordRec[] char102_stroke0 = { + new CoordRec( (float) 38.7752, (float) 100 ), + new CoordRec( (float) 29.2514, (float) 100 ), + new CoordRec( (float) 19.7276, (float) 95.2381 ), + new CoordRec( (float) 14.9657, (float) 80.9524 ), + new CoordRec( (float) 14.9657, (float) 0 ), +}; + +static final CoordRec[] char102_stroke1 = { + new CoordRec( (float) 0.68, (float) 66.6667 ), + new CoordRec( (float) 34.0133, (float) 66.6667 ), +}; + +static final StrokeRec char102[] = { + new StrokeRec(5, char102_stroke0), + new StrokeRec(2, char102_stroke1), +}; + +/* char: 103 'g' */ + +static final CoordRec[] char103_stroke0 = { + new CoordRec( (float) 62.5029, (float) 66.6667 ), + new CoordRec( (float) 62.5029, (float) -9.5238 ), + new CoordRec( (float) 57.741, (float) -23.8095 ), + new CoordRec( (float) 52.979, (float) -28.5714 ), + new CoordRec( (float) 43.4552, (float) -33.3333 ), + new CoordRec( (float) 29.1695, (float) -33.3333 ), + new CoordRec( (float) 19.6457, (float) -28.5714 ), +}; + +static final CoordRec[] char103_stroke1 = { + new CoordRec( (float) 62.5029, (float) 52.381 ), + new CoordRec( (float) 52.979, (float) 61.9048 ), + new CoordRec( (float) 43.4552, (float) 66.6667 ), + new CoordRec( (float) 29.1695, (float) 66.6667 ), + new CoordRec( (float) 19.6457, (float) 61.9048 ), + new CoordRec( (float) 10.1219, (float) 52.381 ), + new CoordRec( (float) 5.36, (float) 38.0952 ), + new CoordRec( (float) 5.36, (float) 28.5714 ), + new CoordRec( (float) 10.1219, (float) 14.2857 ), + new CoordRec( (float) 19.6457, (float) 4.7619 ), + new CoordRec( (float) 29.1695, (float) 0 ), + new CoordRec( (float) 43.4552, (float) 0 ), + new CoordRec( (float) 52.979, (float) 4.7619 ), + new CoordRec( (float) 62.5029, (float) 14.2857 ), +}; + +static final StrokeRec char103[] = { + new StrokeRec(7, char103_stroke0), + new StrokeRec(14, char103_stroke1), +}; + +/* char: 104 'h' */ + +static final CoordRec[] char104_stroke0 = { + new CoordRec( (float) 9.6, (float) 100 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char104_stroke1 = { + new CoordRec( (float) 9.6, (float) 47.619 ), + new CoordRec( (float) 23.8857, (float) 61.9048 ), + new CoordRec( (float) 33.4095, (float) 66.6667 ), + new CoordRec( (float) 47.6952, (float) 66.6667 ), + new CoordRec( (float) 57.219, (float) 61.9048 ), + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final StrokeRec char104[] = { + new StrokeRec(2, char104_stroke0), + new StrokeRec(7, char104_stroke1), +}; + +/* char: 105 'i' */ + +static final CoordRec[] char105_stroke0 = { + new CoordRec( (float) 10.02, (float) 100 ), + new CoordRec( (float) 14.7819, (float) 95.2381 ), + new CoordRec( (float) 19.5438, (float) 100 ), + new CoordRec( (float) 14.7819, (float) 104.762 ), + new CoordRec( (float) 10.02, (float) 100 ), +}; + +static final CoordRec[] char105_stroke1 = { + new CoordRec( (float) 14.7819, (float) 66.6667 ), + new CoordRec( (float) 14.7819, (float) 0 ), +}; + +static final StrokeRec char105[] = { + new StrokeRec(5, char105_stroke0), + new StrokeRec(2, char105_stroke1), +}; + +/* char: 106 'j' */ + +static final CoordRec[] char106_stroke0 = { + new CoordRec( (float) 17.3876, (float) 100 ), + new CoordRec( (float) 22.1495, (float) 95.2381 ), + new CoordRec( (float) 26.9114, (float) 100 ), + new CoordRec( (float) 22.1495, (float) 104.762 ), + new CoordRec( (float) 17.3876, (float) 100 ), +}; + +static final CoordRec[] char106_stroke1 = { + new CoordRec( (float) 22.1495, (float) 66.6667 ), + new CoordRec( (float) 22.1495, (float) -14.2857 ), + new CoordRec( (float) 17.3876, (float) -28.5714 ), + new CoordRec( (float) 7.8638, (float) -33.3333 ), + new CoordRec( (float) -1.66, (float) -33.3333 ), +}; + +static final StrokeRec char106[] = { + new StrokeRec(5, char106_stroke0), + new StrokeRec(5, char106_stroke1), +}; + +/* char: 107 'k' */ + +static final CoordRec[] char107_stroke0 = { + new CoordRec( (float) 9.6, (float) 100 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char107_stroke1 = { + new CoordRec( (float) 57.219, (float) 66.6667 ), + new CoordRec( (float) 9.6, (float) 19.0476 ), +}; + +static final CoordRec[] char107_stroke2 = { + new CoordRec( (float) 28.6476, (float) 38.0952 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final StrokeRec char107[] = { + new StrokeRec(2, char107_stroke0), + new StrokeRec(2, char107_stroke1), + new StrokeRec(2, char107_stroke2), +}; + +/* char: 108 'l' */ + +static final CoordRec[] char108_stroke0 = { + new CoordRec( (float) 10.02, (float) 100 ), + new CoordRec( (float) 10.02, (float) 0 ), +}; + +static final StrokeRec char108[] = { + new StrokeRec(2, char108_stroke0), +}; + +/* char: 109 'm' */ + +static final CoordRec[] char109_stroke0 = { + new CoordRec( (float) 9.6, (float) 66.6667 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char109_stroke1 = { + new CoordRec( (float) 9.6, (float) 47.619 ), + new CoordRec( (float) 23.8857, (float) 61.9048 ), + new CoordRec( (float) 33.4095, (float) 66.6667 ), + new CoordRec( (float) 47.6952, (float) 66.6667 ), + new CoordRec( (float) 57.219, (float) 61.9048 ), + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final CoordRec[] char109_stroke2 = { + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 76.2667, (float) 61.9048 ), + new CoordRec( (float) 85.7905, (float) 66.6667 ), + new CoordRec( (float) 100.076, (float) 66.6667 ), + new CoordRec( (float) 109.6, (float) 61.9048 ), + new CoordRec( (float) 114.362, (float) 47.619 ), + new CoordRec( (float) 114.362, (float) 0 ), +}; + +static final StrokeRec char109[] = { + new StrokeRec(2, char109_stroke0), + new StrokeRec(7, char109_stroke1), + new StrokeRec(7, char109_stroke2), +}; + +/* char: 110 'n' */ + +static final CoordRec[] char110_stroke0 = { + new CoordRec( (float) 9.18, (float) 66.6667 ), + new CoordRec( (float) 9.18, (float) 0 ), +}; + +static final CoordRec[] char110_stroke1 = { + new CoordRec( (float) 9.18, (float) 47.619 ), + new CoordRec( (float) 23.4657, (float) 61.9048 ), + new CoordRec( (float) 32.9895, (float) 66.6667 ), + new CoordRec( (float) 47.2752, (float) 66.6667 ), + new CoordRec( (float) 56.799, (float) 61.9048 ), + new CoordRec( (float) 61.561, (float) 47.619 ), + new CoordRec( (float) 61.561, (float) 0 ), +}; + +static final StrokeRec char110[] = { + new StrokeRec(2, char110_stroke0), + new StrokeRec(7, char110_stroke1), +}; + +/* char: 111 'o' */ + +static final CoordRec[] char111_stroke0 = { + new CoordRec( (float) 28.7895, (float) 66.6667 ), + new CoordRec( (float) 19.2657, (float) 61.9048 ), + new CoordRec( (float) 9.7419, (float) 52.381 ), + new CoordRec( (float) 4.98, (float) 38.0952 ), + new CoordRec( (float) 4.98, (float) 28.5714 ), + new CoordRec( (float) 9.7419, (float) 14.2857 ), + new CoordRec( (float) 19.2657, (float) 4.7619 ), + new CoordRec( (float) 28.7895, (float) 0 ), + new CoordRec( (float) 43.0752, (float) 0 ), + new CoordRec( (float) 52.599, (float) 4.7619 ), + new CoordRec( (float) 62.1229, (float) 14.2857 ), + new CoordRec( (float) 66.8848, (float) 28.5714 ), + new CoordRec( (float) 66.8848, (float) 38.0952 ), + new CoordRec( (float) 62.1229, (float) 52.381 ), + new CoordRec( (float) 52.599, (float) 61.9048 ), + new CoordRec( (float) 43.0752, (float) 66.6667 ), + new CoordRec( (float) 28.7895, (float) 66.6667 ), +}; + +static final StrokeRec char111[] = { + new StrokeRec(17, char111_stroke0), +}; + +/* char: 112 'p' */ + +static final CoordRec[] char112_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) -33.3333 ), +}; + +static final CoordRec[] char112_stroke1 = { + new CoordRec( (float) 9.46, (float) 52.381 ), + new CoordRec( (float) 18.9838, (float) 61.9048 ), + new CoordRec( (float) 28.5076, (float) 66.6667 ), + new CoordRec( (float) 42.7933, (float) 66.6667 ), + new CoordRec( (float) 52.3171, (float) 61.9048 ), + new CoordRec( (float) 61.841, (float) 52.381 ), + new CoordRec( (float) 66.6029, (float) 38.0952 ), + new CoordRec( (float) 66.6029, (float) 28.5714 ), + new CoordRec( (float) 61.841, (float) 14.2857 ), + new CoordRec( (float) 52.3171, (float) 4.7619 ), + new CoordRec( (float) 42.7933, (float) 0 ), + new CoordRec( (float) 28.5076, (float) 0 ), + new CoordRec( (float) 18.9838, (float) 4.7619 ), + new CoordRec( (float) 9.46, (float) 14.2857 ), +}; + +static final StrokeRec char112[] = { + new StrokeRec(2, char112_stroke0), + new StrokeRec(14, char112_stroke1), +}; + +/* char: 113 'q' */ + +static final CoordRec[] char113_stroke0 = { + new CoordRec( (float) 61.9829, (float) 66.6667 ), + new CoordRec( (float) 61.9829, (float) -33.3333 ), +}; + +static final CoordRec[] char113_stroke1 = { + new CoordRec( (float) 61.9829, (float) 52.381 ), + new CoordRec( (float) 52.459, (float) 61.9048 ), + new CoordRec( (float) 42.9352, (float) 66.6667 ), + new CoordRec( (float) 28.6495, (float) 66.6667 ), + new CoordRec( (float) 19.1257, (float) 61.9048 ), + new CoordRec( (float) 9.6019, (float) 52.381 ), + new CoordRec( (float) 4.84, (float) 38.0952 ), + new CoordRec( (float) 4.84, (float) 28.5714 ), + new CoordRec( (float) 9.6019, (float) 14.2857 ), + new CoordRec( (float) 19.1257, (float) 4.7619 ), + new CoordRec( (float) 28.6495, (float) 0 ), + new CoordRec( (float) 42.9352, (float) 0 ), + new CoordRec( (float) 52.459, (float) 4.7619 ), + new CoordRec( (float) 61.9829, (float) 14.2857 ), +}; + +static final StrokeRec char113[] = { + new StrokeRec(2, char113_stroke0), + new StrokeRec(14, char113_stroke1), +}; + +/* char: 114 'r' */ + +static final CoordRec[] char114_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) 0 ), +}; + +static final CoordRec[] char114_stroke1 = { + new CoordRec( (float) 9.46, (float) 38.0952 ), + new CoordRec( (float) 14.2219, (float) 52.381 ), + new CoordRec( (float) 23.7457, (float) 61.9048 ), + new CoordRec( (float) 33.2695, (float) 66.6667 ), + new CoordRec( (float) 47.5552, (float) 66.6667 ), +}; + +static final StrokeRec char114[] = { + new StrokeRec(2, char114_stroke0), + new StrokeRec(5, char114_stroke1), +}; + +/* char: 115 's' */ + +static final CoordRec[] char115_stroke0 = { + new CoordRec( (float) 57.081, (float) 52.381 ), + new CoordRec( (float) 52.319, (float) 61.9048 ), + new CoordRec( (float) 38.0333, (float) 66.6667 ), + new CoordRec( (float) 23.7476, (float) 66.6667 ), + new CoordRec( (float) 9.4619, (float) 61.9048 ), + new CoordRec( (float) 4.7, (float) 52.381 ), + new CoordRec( (float) 9.4619, (float) 42.8571 ), + new CoordRec( (float) 18.9857, (float) 38.0952 ), + new CoordRec( (float) 42.7952, (float) 33.3333 ), + new CoordRec( (float) 52.319, (float) 28.5714 ), + new CoordRec( (float) 57.081, (float) 19.0476 ), + new CoordRec( (float) 57.081, (float) 14.2857 ), + new CoordRec( (float) 52.319, (float) 4.7619 ), + new CoordRec( (float) 38.0333, (float) 0 ), + new CoordRec( (float) 23.7476, (float) 0 ), + new CoordRec( (float) 9.4619, (float) 4.7619 ), + new CoordRec( (float) 4.7, (float) 14.2857 ), +}; + +static final StrokeRec char115[] = { + new StrokeRec(17, char115_stroke0), +}; + +/* char: 116 't' */ + +static final CoordRec[] char116_stroke0 = { + new CoordRec( (float) 14.8257, (float) 100 ), + new CoordRec( (float) 14.8257, (float) 19.0476 ), + new CoordRec( (float) 19.5876, (float) 4.7619 ), + new CoordRec( (float) 29.1114, (float) 0 ), + new CoordRec( (float) 38.6352, (float) 0 ), +}; + +static final CoordRec[] char116_stroke1 = { + new CoordRec( (float) 0.54, (float) 66.6667 ), + new CoordRec( (float) 33.8733, (float) 66.6667 ), +}; + +static final StrokeRec char116[] = { + new StrokeRec(5, char116_stroke0), + new StrokeRec(2, char116_stroke1), +}; + +/* char: 117 'u' */ + +static final CoordRec[] char117_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) 19.0476 ), + new CoordRec( (float) 14.2219, (float) 4.7619 ), + new CoordRec( (float) 23.7457, (float) 0 ), + new CoordRec( (float) 38.0314, (float) 0 ), + new CoordRec( (float) 47.5552, (float) 4.7619 ), + new CoordRec( (float) 61.841, (float) 19.0476 ), +}; + +static final CoordRec[] char117_stroke1 = { + new CoordRec( (float) 61.841, (float) 66.6667 ), + new CoordRec( (float) 61.841, (float) 0 ), +}; + +static final StrokeRec char117[] = { + new StrokeRec(7, char117_stroke0), + new StrokeRec(2, char117_stroke1), +}; + +/* char: 118 'v' */ + +static final CoordRec[] char118_stroke0 = { + new CoordRec( (float) 1.8, (float) 66.6667 ), + new CoordRec( (float) 30.3714, (float) 0 ), +}; + +static final CoordRec[] char118_stroke1 = { + new CoordRec( (float) 58.9429, (float) 66.6667 ), + new CoordRec( (float) 30.3714, (float) 0 ), +}; + +static final StrokeRec char118[] = { + new StrokeRec(2, char118_stroke0), + new StrokeRec(2, char118_stroke1), +}; + +/* char: 119 'w' */ + +static final CoordRec[] char119_stroke0 = { + new CoordRec( (float) 2.5, (float) 66.6667 ), + new CoordRec( (float) 21.5476, (float) 0 ), +}; + +static final CoordRec[] char119_stroke1 = { + new CoordRec( (float) 40.5952, (float) 66.6667 ), + new CoordRec( (float) 21.5476, (float) 0 ), +}; + +static final CoordRec[] char119_stroke2 = { + new CoordRec( (float) 40.5952, (float) 66.6667 ), + new CoordRec( (float) 59.6429, (float) 0 ), +}; + +static final CoordRec[] char119_stroke3 = { + new CoordRec( (float) 78.6905, (float) 66.6667 ), + new CoordRec( (float) 59.6429, (float) 0 ), +}; + +static final StrokeRec char119[] = { + new StrokeRec(2, char119_stroke0), + new StrokeRec(2, char119_stroke1), + new StrokeRec(2, char119_stroke2), + new StrokeRec(2, char119_stroke3), +}; + +/* char: 120 'x' */ + +static final CoordRec[] char120_stroke0 = { + new CoordRec( (float) 1.66, (float) 66.6667 ), + new CoordRec( (float) 54.041, (float) 0 ), +}; + +static final CoordRec[] char120_stroke1 = { + new CoordRec( (float) 54.041, (float) 66.6667 ), + new CoordRec( (float) 1.66, (float) 0 ), +}; + +static final StrokeRec char120[] = { + new StrokeRec(2, char120_stroke0), + new StrokeRec(2, char120_stroke1), +}; + +/* char: 121 'y' */ + +static final CoordRec[] char121_stroke0 = { + new CoordRec( (float) 6.5619, (float) 66.6667 ), + new CoordRec( (float) 35.1333, (float) 0 ), +}; + +static final CoordRec[] char121_stroke1 = { + new CoordRec( (float) 63.7048, (float) 66.6667 ), + new CoordRec( (float) 35.1333, (float) 0 ), + new CoordRec( (float) 25.6095, (float) -19.0476 ), + new CoordRec( (float) 16.0857, (float) -28.5714 ), + new CoordRec( (float) 6.5619, (float) -33.3333 ), + new CoordRec( (float) 1.8, (float) -33.3333 ), +}; + +static final StrokeRec char121[] = { + new StrokeRec(2, char121_stroke0), + new StrokeRec(6, char121_stroke1), +}; + +/* char: 122 'z' */ + +static final CoordRec[] char122_stroke0 = { + new CoordRec( (float) 56.821, (float) 66.6667 ), + new CoordRec( (float) 4.44, (float) 0 ), +}; + +static final CoordRec[] char122_stroke1 = { + new CoordRec( (float) 4.44, (float) 66.6667 ), + new CoordRec( (float) 56.821, (float) 66.6667 ), +}; + +static final CoordRec[] char122_stroke2 = { + new CoordRec( (float) 4.44, (float) 0 ), + new CoordRec( (float) 56.821, (float) 0 ), +}; + +static final StrokeRec char122[] = { + new StrokeRec(2, char122_stroke0), + new StrokeRec(2, char122_stroke1), + new StrokeRec(2, char122_stroke2), +}; + +/* char: 123 '{' */ + +static final CoordRec[] char123_stroke0 = { + new CoordRec( (float) 31.1895, (float) 119.048 ), + new CoordRec( (float) 21.6657, (float) 114.286 ), + new CoordRec( (float) 16.9038, (float) 109.524 ), + new CoordRec( (float) 12.1419, (float) 100 ), + new CoordRec( (float) 12.1419, (float) 90.4762 ), + new CoordRec( (float) 16.9038, (float) 80.9524 ), + new CoordRec( (float) 21.6657, (float) 76.1905 ), + new CoordRec( (float) 26.4276, (float) 66.6667 ), + new CoordRec( (float) 26.4276, (float) 57.1429 ), + new CoordRec( (float) 16.9038, (float) 47.619 ), +}; + +static final CoordRec[] char123_stroke1 = { + new CoordRec( (float) 21.6657, (float) 114.286 ), + new CoordRec( (float) 16.9038, (float) 104.762 ), + new CoordRec( (float) 16.9038, (float) 95.2381 ), + new CoordRec( (float) 21.6657, (float) 85.7143 ), + new CoordRec( (float) 26.4276, (float) 80.9524 ), + new CoordRec( (float) 31.1895, (float) 71.4286 ), + new CoordRec( (float) 31.1895, (float) 61.9048 ), + new CoordRec( (float) 26.4276, (float) 52.381 ), + new CoordRec( (float) 7.38, (float) 42.8571 ), + new CoordRec( (float) 26.4276, (float) 33.3333 ), + new CoordRec( (float) 31.1895, (float) 23.8095 ), + new CoordRec( (float) 31.1895, (float) 14.2857 ), + new CoordRec( (float) 26.4276, (float) 4.7619 ), + new CoordRec( (float) 21.6657, (float) 0 ), + new CoordRec( (float) 16.9038, (float) -9.5238 ), + new CoordRec( (float) 16.9038, (float) -19.0476 ), + new CoordRec( (float) 21.6657, (float) -28.5714 ), +}; + +static final CoordRec[] char123_stroke2 = { + new CoordRec( (float) 16.9038, (float) 38.0952 ), + new CoordRec( (float) 26.4276, (float) 28.5714 ), + new CoordRec( (float) 26.4276, (float) 19.0476 ), + new CoordRec( (float) 21.6657, (float) 9.5238 ), + new CoordRec( (float) 16.9038, (float) 4.7619 ), + new CoordRec( (float) 12.1419, (float) -4.7619 ), + new CoordRec( (float) 12.1419, (float) -14.2857 ), + new CoordRec( (float) 16.9038, (float) -23.8095 ), + new CoordRec( (float) 21.6657, (float) -28.5714 ), + new CoordRec( (float) 31.1895, (float) -33.3333 ), +}; + +static final StrokeRec char123[] = { + new StrokeRec(10, char123_stroke0), + new StrokeRec(17, char123_stroke1), + new StrokeRec(10, char123_stroke2), +}; + +/* char: 124 '|' */ + +static final CoordRec[] char124_stroke0 = { + new CoordRec( (float) 11.54, (float) 119.048 ), + new CoordRec( (float) 11.54, (float) -33.3333 ), +}; + +static final StrokeRec char124[] = { + new StrokeRec(2, char124_stroke0), +}; + +/* char: 125 '}' */ + +static final CoordRec[] char125_stroke0 = { + new CoordRec( (float) 9.18, (float) 119.048 ), + new CoordRec( (float) 18.7038, (float) 114.286 ), + new CoordRec( (float) 23.4657, (float) 109.524 ), + new CoordRec( (float) 28.2276, (float) 100 ), + new CoordRec( (float) 28.2276, (float) 90.4762 ), + new CoordRec( (float) 23.4657, (float) 80.9524 ), + new CoordRec( (float) 18.7038, (float) 76.1905 ), + new CoordRec( (float) 13.9419, (float) 66.6667 ), + new CoordRec( (float) 13.9419, (float) 57.1429 ), + new CoordRec( (float) 23.4657, (float) 47.619 ), +}; + +static final CoordRec[] char125_stroke1 = { + new CoordRec( (float) 18.7038, (float) 114.286 ), + new CoordRec( (float) 23.4657, (float) 104.762 ), + new CoordRec( (float) 23.4657, (float) 95.2381 ), + new CoordRec( (float) 18.7038, (float) 85.7143 ), + new CoordRec( (float) 13.9419, (float) 80.9524 ), + new CoordRec( (float) 9.18, (float) 71.4286 ), + new CoordRec( (float) 9.18, (float) 61.9048 ), + new CoordRec( (float) 13.9419, (float) 52.381 ), + new CoordRec( (float) 32.9895, (float) 42.8571 ), + new CoordRec( (float) 13.9419, (float) 33.3333 ), + new CoordRec( (float) 9.18, (float) 23.8095 ), + new CoordRec( (float) 9.18, (float) 14.2857 ), + new CoordRec( (float) 13.9419, (float) 4.7619 ), + new CoordRec( (float) 18.7038, (float) 0 ), + new CoordRec( (float) 23.4657, (float) -9.5238 ), + new CoordRec( (float) 23.4657, (float) -19.0476 ), + new CoordRec( (float) 18.7038, (float) -28.5714 ), +}; + +static final CoordRec[] char125_stroke2 = { + new CoordRec( (float) 23.4657, (float) 38.0952 ), + new CoordRec( (float) 13.9419, (float) 28.5714 ), + new CoordRec( (float) 13.9419, (float) 19.0476 ), + new CoordRec( (float) 18.7038, (float) 9.5238 ), + new CoordRec( (float) 23.4657, (float) 4.7619 ), + new CoordRec( (float) 28.2276, (float) -4.7619 ), + new CoordRec( (float) 28.2276, (float) -14.2857 ), + new CoordRec( (float) 23.4657, (float) -23.8095 ), + new CoordRec( (float) 18.7038, (float) -28.5714 ), + new CoordRec( (float) 9.18, (float) -33.3333 ), +}; + +static final StrokeRec char125[] = { + new StrokeRec(10, char125_stroke0), + new StrokeRec(17, char125_stroke1), + new StrokeRec(10, char125_stroke2), +}; + +/* char: 126 '~' */ + +static final CoordRec[] char126_stroke0 = { + new CoordRec( (float) 2.92, (float) 28.5714 ), + new CoordRec( (float) 2.92, (float) 38.0952 ), + new CoordRec( (float) 7.6819, (float) 52.381 ), + new CoordRec( (float) 17.2057, (float) 57.1429 ), + new CoordRec( (float) 26.7295, (float) 57.1429 ), + new CoordRec( (float) 36.2533, (float) 52.381 ), + new CoordRec( (float) 55.301, (float) 38.0952 ), + new CoordRec( (float) 64.8248, (float) 33.3333 ), + new CoordRec( (float) 74.3486, (float) 33.3333 ), + new CoordRec( (float) 83.8724, (float) 38.0952 ), + new CoordRec( (float) 88.6343, (float) 47.619 ), +}; + +static final CoordRec[] char126_stroke1 = { + new CoordRec( (float) 2.92, (float) 38.0952 ), + new CoordRec( (float) 7.6819, (float) 47.619 ), + new CoordRec( (float) 17.2057, (float) 52.381 ), + new CoordRec( (float) 26.7295, (float) 52.381 ), + new CoordRec( (float) 36.2533, (float) 47.619 ), + new CoordRec( (float) 55.301, (float) 33.3333 ), + new CoordRec( (float) 64.8248, (float) 28.5714 ), + new CoordRec( (float) 74.3486, (float) 28.5714 ), + new CoordRec( (float) 83.8724, (float) 33.3333 ), + new CoordRec( (float) 88.6343, (float) 47.619 ), + new CoordRec( (float) 88.6343, (float) 57.1429 ), +}; + +static final StrokeRec char126[] = { + new StrokeRec(11, char126_stroke0), + new StrokeRec(11, char126_stroke1), +}; + +/* char: 127 */ + +static final CoordRec[] char127_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 14.2857, (float) -33.3333 ), +}; + +static final CoordRec[] char127_stroke1 = { + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 4.7619, (float) 52.381 ), + new CoordRec( (float) 0, (float) 38.0952 ), + new CoordRec( (float) 0, (float) 23.8095 ), + new CoordRec( (float) 4.7619, (float) 14.2857 ), + new CoordRec( (float) 14.2857, (float) 4.7619 ), + new CoordRec( (float) 28.5714, (float) 0 ), + new CoordRec( (float) 38.0952, (float) 0 ), + new CoordRec( (float) 52.381, (float) 4.7619 ), + new CoordRec( (float) 61.9048, (float) 14.2857 ), + new CoordRec( (float) 66.6667, (float) 28.5714 ), + new CoordRec( (float) 66.6667, (float) 42.8571 ), + new CoordRec( (float) 61.9048, (float) 52.381 ), + new CoordRec( (float) 52.381, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), +}; + +static final StrokeRec char127[] = { + new StrokeRec(2, char127_stroke0), + new StrokeRec(17, char127_stroke1), +}; + +static final StrokeCharRec chars[] = { + new StrokeCharRec( 0, /* char0 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char1 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char2 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char3 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char4 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char5 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char6 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char7 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char8 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char9 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char10 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char11 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char12 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char13 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char14 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char15 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char16 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char17 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char18 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char19 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char20 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char21 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char22 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char23 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char24 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char25 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char26 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char27 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char28 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char29 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char30 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char31 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char32 */ null, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char33, (float)13.3819, (float)26.6238 ), + new StrokeCharRec( 2, char34, (float)23.0676, (float)51.4352 ), + new StrokeCharRec( 4, char35, (float)36.5333, (float)79.4886 ), + new StrokeCharRec( 3, char36, (float)38.1533, (float)76.2067 ), + new StrokeCharRec( 3, char37, (float)49.2171, (float)96.5743 ), + new StrokeCharRec( 1, char38, (float)53.599, (float)101.758 ), + new StrokeCharRec( 1, char39, (float)4.44, (float)13.62 ), + new StrokeCharRec( 1, char40, (float)21.8657, (float)47.1733 ), + new StrokeCharRec( 1, char41, (float)24.3276, (float)47.5333 ), + new StrokeCharRec( 3, char42, (float)30.7695, (float)59.439 ), + new StrokeCharRec( 2, char43, (float)48.8371, (float)97.2543 ), + new StrokeCharRec( 1, char44, (float)13.5219, (float)26.0638 ), + new StrokeCharRec( 1, char45, (float)50.2371, (float)100.754 ), + new StrokeCharRec( 1, char46, (float)13.1019, (float)26.4838 ), + new StrokeCharRec( 1, char47, (float)40.5733, (float)82.1067 ), + new StrokeCharRec( 1, char48, (float)38.3133, (float)77.0667 ), + new StrokeCharRec( 1, char49, (float)30.8676, (float)66.5295 ), + new StrokeCharRec( 1, char50, (float)38.7533, (float)77.6467 ), + new StrokeCharRec( 1, char51, (float)38.3333, (float)77.0467 ), + new StrokeCharRec( 2, char52, (float)37.2133, (float)80.1686 ), + new StrokeCharRec( 1, char53, (float)38.1933, (float)77.6867 ), + new StrokeCharRec( 1, char54, (float)34.1514, (float)73.8048 ), + new StrokeCharRec( 2, char55, (float)38.8933, (float)77.2267 ), + new StrokeCharRec( 1, char56, (float)38.9333, (float)77.6667 ), + new StrokeCharRec( 1, char57, (float)39.9333, (float)74.0648 ), + new StrokeCharRec( 2, char58, (float)14.0819, (float)26.2238 ), + new StrokeCharRec( 2, char59, (float)12.9619, (float)26.3038 ), + new StrokeCharRec( 1, char60, (float)41.1552, (float)81.6105 ), + new StrokeCharRec( 2, char61, (float)48.5571, (float)97.2543 ), + new StrokeCharRec( 1, char62, (float)40.8752, (float)81.6105 ), + new StrokeCharRec( 2, char63, (float)36.9914, (float)73.9029 ), + new StrokeCharRec( 2, char64, (float)34.9314, (float)74.3648 ), + new StrokeCharRec( 3, char65, (float)40.5952, (float)80.4905 ), + new StrokeCharRec( 3, char66, (float)44.7533, (float)83.6267 ), + new StrokeCharRec( 1, char67, (float)39.9933, (float)84.4886 ), + new StrokeCharRec( 2, char68, (float)45.2933, (float)85.2867 ), + new StrokeCharRec( 4, char69, (float)39.9914, (float)78.1848 ), + new StrokeCharRec( 3, char70, (float)39.9914, (float)78.7448 ), + new StrokeCharRec( 2, char71, (float)40.3933, (float)89.7686 ), + new StrokeCharRec( 3, char72, (float)44.7533, (float)89.0867 ), + new StrokeCharRec( 1, char73, (float)10.86, (float)21.3 ), + new StrokeCharRec( 1, char74, (float)31.0714, (float)59.999 ), + new StrokeCharRec( 3, char75, (float)44.6133, (float)79.3267 ), + new StrokeCharRec( 2, char76, (float)40.2514, (float)71.3229 ), + new StrokeCharRec( 4, char77, (float)48.9552, (float)97.2105 ), + new StrokeCharRec( 3, char78, (float)44.4733, (float)88.8067 ), + new StrokeCharRec( 1, char79, (float)44.3352, (float)88.8305 ), + new StrokeCharRec( 2, char80, (float)45.4333, (float)85.6667 ), + new StrokeCharRec( 2, char81, (float)43.3952, (float)88.0905 ), + new StrokeCharRec( 3, char82, (float)45.0133, (float)82.3667 ), + new StrokeCharRec( 1, char83, (float)41.3333, (float)80.8267 ), + new StrokeCharRec( 2, char84, (float)35.6933, (float)71.9467 ), + new StrokeCharRec( 1, char85, (float)44.8733, (float)89.4867 ), + new StrokeCharRec( 2, char86, (float)40.4552, (float)81.6105 ), + new StrokeCharRec( 4, char87, (float)49.839, (float)100.518 ), + new StrokeCharRec( 2, char88, (float)35.8333, (float)72.3667 ), + new StrokeCharRec( 2, char89, (float)39.6152, (float)79.6505 ), + new StrokeCharRec( 3, char90, (float)35.8333, (float)73.7467 ), + new StrokeCharRec( 4, char91, (float)22.0657, (float)46.1133 ), + new StrokeCharRec( 1, char92, (float)39.1733, (float)78.2067 ), + new StrokeCharRec( 4, char93, (float)23.4876, (float)46.3933 ), + new StrokeCharRec( 2, char94, (float)44.0752, (float)90.2305 ), + new StrokeCharRec( 1, char95, (float)51.281, (float)104.062 ), + new StrokeCharRec( 2, char96, (float)42.5457, (float)83.5714 ), + new StrokeCharRec( 2, char97, (float)35.2514, (float)66.6029 ), + new StrokeCharRec( 2, char98, (float)37.3314, (float)70.4629 ), + new StrokeCharRec( 1, char99, (float)34.0914, (float)68.9229 ), + new StrokeCharRec( 2, char100, (float)33.2114, (float)70.2629 ), + new StrokeCharRec( 1, char101, (float)34.2914, (float)68.5229 ), + new StrokeCharRec( 2, char102, (float)14.9657, (float)38.6552 ), + new StrokeCharRec( 2, char103, (float)33.9314, (float)70.9829 ), + new StrokeCharRec( 2, char104, (float)33.4095, (float)71.021 ), + new StrokeCharRec( 2, char105, (float)14.7819, (float)28.8638 ), + new StrokeCharRec( 2, char106, (float)17.3876, (float)36.2314 ), + new StrokeCharRec( 3, char107, (float)33.4095, (float)62.521 ), + new StrokeCharRec( 1, char108, (float)10.02, (float)19.34 ), + new StrokeCharRec( 3, char109, (float)61.981, (float)123.962 ), + new StrokeCharRec( 2, char110, (float)32.9895, (float)70.881 ), + new StrokeCharRec( 1, char111, (float)33.5514, (float)71.7448 ), + new StrokeCharRec( 2, char112, (float)38.0314, (float)70.8029 ), + new StrokeCharRec( 2, char113, (float)33.4114, (float)70.7429 ), + new StrokeCharRec( 2, char114, (float)23.7457, (float)49.4952 ), + new StrokeCharRec( 1, char115, (float)28.5095, (float)62.321 ), + new StrokeCharRec( 2, char116, (float)14.8257, (float)39.3152 ), + new StrokeCharRec( 2, char117, (float)33.2695, (float)71.161 ), + new StrokeCharRec( 2, char118, (float)30.3714, (float)60.6029 ), + new StrokeCharRec( 4, char119, (float)40.5952, (float)80.4905 ), + new StrokeCharRec( 2, char120, (float)25.4695, (float)56.401 ), + new StrokeCharRec( 2, char121, (float)35.1333, (float)66.0648 ), + new StrokeCharRec( 3, char122, (float)28.2495, (float)61.821 ), + new StrokeCharRec( 3, char123, (float)21.6657, (float)41.6295 ), + new StrokeCharRec( 1, char124, (float)11.54, (float)23.78 ), + new StrokeCharRec( 3, char125, (float)18.7038, (float)41.4695 ), + new StrokeCharRec( 2, char126, (float)45.7771, (float)91.2743 ), + new StrokeCharRec( 2, char127, (float)33.3333, (float)66.6667 ), +}; + +final static StrokeFontRec fontinfo = new StrokeFontRec( "Roman", 128, chars, (float)119.048, (float)-33.3333 ); + + static public StrokeFontRec getStrokeFontRec() { + return fontinfo; + } +} diff --git a/gl4java/utils/glut/fonts/stroke.h b/gl4java/utils/glut/fonts/stroke.h new file mode 100644 index 0000000..fc29680 --- /dev/null +++ b/gl4java/utils/glut/fonts/stroke.h @@ -0,0 +1,134 @@ +/* $XConsortium: wfont.h,v 5.1 91/02/16 09:46:37 rws Exp $ */ + +/***************************************************************** +Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Sun Microsystems, +the X Consortium, and MIT not be used in advertising or publicity +pertaining to distribution of the software without specific, written +prior permission. + +SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT +SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#ifndef WFONT_INCLUDED +#define WFONT_INCLUDED + +#define WFONT_MAGIC 0x813 +#define WFONT_MAGIC_PLUS 0x715 +#define WFONT_MAGIC_PEX 0x70686e74 +#define START_PROPS 0x100 +#define START_DISPATCH(_num_props) (START_PROPS + 160 * _num_props) +#define START_PATH(_num_ch_, _num_props) (START_DISPATCH(_num_props) + sizeof(Dispatch) * _num_ch_) +#define NUM_DISPATCH 128 + +typedef struct { + unsigned short x; + unsigned short y; +} Path_point2dpx; + +typedef struct { + float x; + float y; +} Path_point2df; + +typedef struct { + int x; + int y; + int z; +} Path_point3di; + +typedef struct { + float x; + float y; + float z; +} Path_point3df; + +typedef struct { + float x; + float y; + float z; + float w; +} Path_point4df; + +typedef union { + Path_point2dpx *pt2dpx; + Path_point2df *pt2df; + Path_point3di *pt3di; + Path_point3df *pt3df; + Path_point4df *pt4df; +} Path_pt_ptr; + +typedef enum { + PATH_2DF, + PATH_2DPX, + PATH_3DF, + PATH_3DI, + PATH_4DF +} Path_type; + +typedef struct { + int n_pts; /* number of points in the subpath */ + Path_pt_ptr pts; /* pointer to them */ + int closed; /* true if the subpath is closed */ + int dcmp_flag; /* flag for pgon dcmp, pgon type + * and dcmped triangle type */ +} Path_subpath; + +typedef struct { + Path_type type; /* type of vertices in this path */ + int n_subpaths; /* number of subpaths */ + int n_vertices; /* total number of vertices */ + Path_subpath *subpaths; /* array of subpaths */ +} Path; + +typedef Path *Path_handle; + +typedef struct { + char propname[80]; /* font property name */ + char propvalue[80]; /* font property value */ +} Property; + +typedef struct { + int magic; /* magic number */ + char name[80]; /* name of this font */ + float top, /* extreme values */ + bottom, max_width; + int num_ch; /* no. of fonts in the set */ + int num_props; /* no. of font properties */ + Property *properties; /* array of properties */ +} Font_header; + +typedef struct { + float center, /* center of the character */ + right; /* right edge */ + long offset; /* offset in the file of the character + * * description */ +} Dispatch; + +typedef struct { + float center, right; + Path strokes; +} Ch_font; + +typedef struct { + char name[80]; + float top, bottom, max_width; + int num_ch; /* # characters in the font */ + Ch_font **ch_data; +} Phg_font; + +#endif /*WFONT_INCLUDED */ diff --git a/gl4java/utils/glut/fonts/strokegen.y b/gl4java/utils/glut/fonts/strokegen.y new file mode 100644 index 0000000..83614fc --- /dev/null +++ b/gl4java/utils/glut/fonts/strokegen.y @@ -0,0 +1,658 @@ +%{ +/* $XConsortium: to_wfont.y,v 5.7 94/04/17 20:10:08 rws Exp $ */ + +/***************************************************************** + +Copyright (c) 1989,1990, 1991 X Consortium + +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 THE +X CONSORTIUM 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. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Sun Microsystems, +and the X Consortium, not be used in advertising or publicity +pertaining to distribution of the software without specific, written +prior permission. + +SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT +SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +/* Adapted to produce Java output by Pontus Lidman + portions copyright 2000 MathCore AB */ + +#define YYMAXDEPTH 10000 + +#include +#include +#include +#ifndef L_SET +#define L_SET SEEK_SET +#endif +#include "stroke.h" + +#ifdef X_NOT_STDC_ENV +FILE *fopen(); +#endif + +typedef struct { + + float std_left, /* NCGA standard left spacing */ + std_wide, /* character width */ + std_rght; /* Right spacing */ +} Standard; + + +char fname[80]; +char symname[80] = "FONT"; +Dispatch *Table; /* dispatch table */ +Standard *sp_table; /* NCGA font spacings */ +Path *strokes; /* strokes of each character */ +Property *property; /* property list */ + +struct { + int path, point, props; +} count, expect; + +Path_subpath *current_path; + +Font_header head; /* font header */ +int tableindex; /* which character */ +int yyerrno; /* error number */ + +%} + +%union { + int nil; /* void is reserved */ + int ival; + float dval; + char *cval; +} + +%start font + +%token REAL +%token INTEGER +%token STRING + +%token BOTTOM +%token CENTER +%token CLOSE +%token FONTNAME +%token PROPERTIES +%token NUM_CH +%token INDEX +%token L_SPACE +%token MAGIC +%token OPEN +%token RIGHT +%token R_SPACE +%token STROKE +%token TOP +%token VERTICES +%token BEARING +%token WIDTH + +%type fontname +%type properties +%type top bottom center right +%type nstroke nvertice n_pts index num_ch +%type closeflag +%type counter +%type sp_left wide sp_right + +%% + +font : fontheader num_ch fontprops fontbody spacing { fini(); }| + fontheader fontbody { fini(); }; + +fontheader : fontname top bottom + { wf_header($1, $2, $3); }; + +fontname : FONTNAME STRING + { $$ = $2; }; + +top : TOP REAL { $$ = $2;}; + +bottom : BOTTOM REAL { $$ = $2;}; + +num_ch: NUM_CH INTEGER { set_num_ch($2);}; + +fontprops : /* empty */ | properties { } ; + +properties : PROPERTIES INTEGER { init_properties ($2); } property_list + { check_num_props (); } + +property_list : /* empty */ | single_property property_list + +single_property : STRING STRING { add_property($1, $2); }; + +fontbody : /* empty */ + | glyph fontbody; + +glyph : glyph_header strokes + { check_nstroke(); }; + +glyph_header : index { tableindex = $1; } sym_headinfo; + +sym_headinfo : nstroke center right nvertice + { glyph_header($1, $2, $3, $4); }; + +index : INDEX INTEGER { check_num_ch(); $$ = $2; }; + +nstroke : STROKE INTEGER { $$ = $2; expect.path = $2; }; + +nvertice: {$$ = 0;} | VERTICES INTEGER { $$ = $2; } ; + +center : CENTER REAL{ $$ = $2; }; + +right : RIGHT REAL{ $$ = $2; }; + +strokes : /* empty */ | path strokes; + +path : closeflag n_pts { init_path($1, $2); } points + { check_npts(); } + +points : /* empty */ | coord points; + +closeflag : CLOSE { $$ = $1 == CLOSE; } | OPEN { $$ = $1 == CLOSE; } ; + +n_pts : INTEGER { $$ = $1; }; + +coord : REAL REAL { add_point($1, $2); }; + +spacing : /* empty */ + | item spacing; + +item : counter {tableindex = $1;} sp_left wide sp_right + { std_space($3, $4, $5); }; + +counter : BEARING INTEGER {$$ = $2;}; + +sp_left: L_SPACE REAL {$$ = $2;}; + +wide : WIDTH REAL {$$ = $2;}; + +sp_right: R_SPACE REAL {$$ = $2;}; + +%% + +#define BYE(err) yyerrno = (err), yyerror() + +#define ERR_BASE 1000 +#define OPEN_ERROR 1001 +#define WRITE_ERROR 1002 +#define WRONG_NAME 1003 +#define NO_MEMORY 1004 +#define EXCEED_PATH 1005 +#define EXCEED_POINT 1006 +#define PATH_MISMATCH 1007 +#define POINT_MISMATCH 1008 +#define PROP_MISMATCH 1009 +#define EXCEED_PROPS 1010 + +char *prog; + +main(argc, argv) + int argc; + char *argv[]; + +{ + /* Usage : to_wfont [-o outfile] [infile] */ + char *s; + + fname[0] = 0; + tableindex = 0; + head.num_ch = -1; + + prog = *argv; + while (--argc > 0 && *++argv != NULL) { + s = *argv; + if (*s++ == '-') + switch (*s) { + case 's': + if (*++argv != NULL) + { + --argc; + (void) strcpy(symname, *argv); + } + break; + case 'o': + if (*++argv != NULL) + { + --argc; + (void) strcpy(fname, *argv); + } + break; + default: /* ignore other options */ + ; + } + else { + FILE *fp; + + /* standard input redirection */ + fp = fopen(*argv, "r"); + if (fp != NULL) { + if (close(fileno(stdin)) < 0) + { + perror(prog); + return; + } + if (dup(fileno(fp)) < 0) + { + perror(prog); + return; + } + (void) fclose(fp); + } + } + } + return (yyparse()); +} + +/* set number of characters */ +set_num_ch(num_ch) +int num_ch; +{ + yyerrno = 0; + head.num_ch = num_ch; + if (num_ch > 0) { + Table = (Dispatch *) malloc(num_ch * sizeof(Dispatch)); + sp_table = (Standard *) malloc(num_ch * sizeof(Standard)); + strokes = (Path *) malloc(num_ch * sizeof(Path)); + } + + for (tableindex = 0; tableindex < num_ch; tableindex++) { + Table[tableindex].center = 0.0; + Table[tableindex].right = 0.0; + Table[tableindex].offset = 0; + + sp_table[tableindex].std_left = 0.0; + sp_table[tableindex].std_wide = 0.0; + sp_table[tableindex].std_rght = 0.0; + + strokes[tableindex].n_subpaths = 0; + strokes[tableindex].n_vertices = 0; + strokes[tableindex].subpaths = NULL; + } +} + +/* initialize the property info in the header */ +init_properties(num_props) + int num_props; +{ + if (num_props > 0) { + head.properties = (Property *) + malloc (num_props * sizeof (Property)); + head.num_props = expect.props = num_props; + } + else { + head.properties = NULL; + head.num_props = expect.props = 0; + } + count.props = -1; + property = head.properties; /* initialize the list pointer */ +} + +check_num_props() +{ + count.props++; + if (count.props != expect.props) + BYE (PROP_MISMATCH); +} + +/* add individual property info into the buffer */ +add_property(name, value) + char *name, + *value; +{ + /* check if the property exceeds allocated space */ + + if (++count.props >= head.num_props) + BYE(EXCEED_PROPS); + + /* copy the strings into the buffer */ + + (void) strcpy (property->propname, name); + (void) strcpy (property->propvalue, value); + + /* increment the property pointer */ + + property++; +} + +check_num_ch() +{ + + if (head.num_ch == -1) + set_num_ch(128); + +} + +yyerror() +{ +#ifndef __bsdi__ + extern int yylineno; +#endif +# define ERR_SIZE (sizeof(err_string) / sizeof(char *)) + static char *err_string[] = { + "Cannot open file", + "Write fails", + "Illegal font name", + "Memory allocation failure", + "Specified number of strokes exceeded", + "Specified number of points exceeded", + "Number of strokes do not match", + "Number of points do not match", + "Number of properties do not match", + "Specified number of properties exceeded", + 0}; + char *str; + + yyerrno -= ERR_BASE; + if (yyerrno > 0 && yyerrno < ERR_SIZE) + str = err_string[yyerrno-1]; + else + str = "Syntax error"; +#ifdef __bsdi__ + fprintf(stderr, "%s.\n", str); +#else + fprintf(stderr, "line %d: %s.\n", yylineno, str); +#endif + freeall(); + (void) unlink(fname); + exit(1); +} + +/* create wfont header */ +wf_header(name, top, bottom) + char *name; + float top, + bottom; +{ + + if (name == NULL) + BYE(WRONG_NAME); + head.top = (float) top; + head.bottom = (float) bottom; + head.magic = WFONT_MAGIC_PEX; + (void) strcpy(head.name, name); + free(name); +} + +/* create header for each glyph */ +glyph_header(npath, center, right, npts) + int npath, + npts; + float center, + right; +{ + { + register Path *strk = strokes + tableindex; + + if (npath > 0) /* Don't allocate space unless the character + has strokes associated with it. */ + { + strk->subpaths = (Path_subpath *) + malloc(npath * sizeof (Path_subpath)); + + if (strk->subpaths == NULL) + BYE(NO_MEMORY); + + strk->type = PATH_2DF; + strk->n_subpaths = npath; + strk->n_vertices = npts; + } + else { /* Just initialize the entry */ + strk->subpaths = NULL; + strk->type = PATH_2DF; + strk->n_subpaths = 0; + strk->n_vertices = 0; + } + } + { + register Dispatch *tbl = Table + tableindex; + + tbl->offset = 0; + tbl->center = center; + tbl->right = right; + } + count.path = -1; /* initialize path counter, not to + * exceed n_subpath */ +} + +/* create standard spacing info for each glyph */ +std_space(l_bear, wide, r_bear) + + float l_bear, + wide, + r_bear; +{ + register Standard *tbl = sp_table +tableindex; + tbl->std_left = l_bear; + tbl->std_wide = wide; + tbl->std_rght = r_bear; +} + +/* initialize each sub_path */ +init_path(close, n) + int close, + n; +{ + register Path_subpath *path; + + if (++count.path >= strokes[tableindex].n_subpaths) + BYE(EXCEED_PATH); + path = current_path = strokes[tableindex].subpaths + count.path; + path->n_pts = n; + path->closed = close; + if (n > 0) + path->pts.pt2df = (Path_point2df *) + malloc(n * sizeof (Path_point2df)); + if (path->pts.pt2df == NULL) + BYE(NO_MEMORY); + expect.point = path->n_pts; + count.point = -1; /* initialize point counter, not to + * exceed n_pts */ +} + +/* accumulating points for each sub_path */ +add_point(x, y) + float x, + y; +{ + register Path_subpath *path; + register Path_point2df *pt_ptr; + + path = current_path; + if (++count.point >= path->n_pts) + BYE(EXCEED_POINT); + pt_ptr = path->pts.pt2df + count.point; + pt_ptr->x = x; + pt_ptr->y = y; +} + +/* Path_type + n_subpaths + n_vertices */ +#define STROKE_HEAD (sizeof (Path_type) + sizeof (int) + sizeof (int)) + +/* write out file, close everything, free everything */ +fini() +{ + static long zero = 0; + + /* pointers used to walk the arrays */ + register Path_subpath *spath; + register Dispatch *tbl_ptr; + register Path *strptr; + register Property *prop_ptr; + + FILE *fp; + int npath; + register int i, + j, + k; + Standard *sp_ptr; + Path_point2df *pt; + + printf("\n/* GENERATED FILE -- DO NOT MODIFY */\n\n"); +/* printf("#include \"glutstroke.h\"\n\n"); */ + + printf("package gl4java.utils.glut.fonts.data;\n\n"); + printf("import gl4java.utils.glut.fonts.*;\n\n"); + printf("public class %s implements GLUTStrokeFont {\n",symname); + +# define BY_BYE(err) fclose(fp), BYE(err) + + /* adjust the characters for spacing, note max char width */ + head.max_width = 0.0; + for (i = 0, tbl_ptr = Table, strptr = strokes, sp_ptr = sp_table; + i < head.num_ch; i++, tbl_ptr++, strptr++, sp_ptr++) { + tbl_ptr->center += sp_ptr->std_left; + tbl_ptr->right += sp_ptr->std_left + sp_ptr->std_rght; + if (tbl_ptr->right > head.max_width) + head.max_width = tbl_ptr->right; + npath = strptr->n_subpaths; + if (npath > 0 || tbl_ptr->center != 0.0 || + tbl_ptr->right != 0.0) { + for (j = 0, spath = strptr->subpaths; + j < npath; j++, spath++) { + for(k=0, pt = spath->pts.pt2df; + kn_pts; k++, pt++) { + pt->x += sp_ptr->std_left; + } + } + } + } + + /* write the stroke table */ + for (i = 0, tbl_ptr = Table, strptr = strokes; + i < head.num_ch; i++, tbl_ptr++, strptr++) { + if (strptr->n_subpaths > 0 && + tbl_ptr->center != 0.0 && + tbl_ptr->right != 0.0) { + if(isprint(i)) { + printf("/* char: %d '%c' */\n\n", i, i); + } else { + printf("/* char: %d */\n\n", i); + } + + for (j = 0, spath = strptr->subpaths; + j < strptr->n_subpaths; j++, spath++) { + int z; + + printf("static final CoordRec[] char%d_stroke%d = {\n", i, j); + for(z = 0; z < spath->n_pts; z++) { + printf(" new CoordRec( (float) %g, (float) %g ),\n", + spath->pts.pt2df[z].x, spath->pts.pt2df[z].y); + } + printf("};\n\n"); + } + + printf("static final StrokeRec char%d[] = {\n", i); + for (j = 0, spath = strptr->subpaths; + j < strptr->n_subpaths; j++, spath++) { + printf(" new StrokeRec(%d, char%d_stroke%d),\n", + spath->n_pts, i, j); + } + printf("};\n\n"); + } + } + printf("static final StrokeCharRec chars[] = {\n"); + for (i = 0, tbl_ptr = Table, strptr = strokes; + i < head.num_ch; i++, tbl_ptr++, strptr++) { + if (strptr->n_subpaths > 0 && + tbl_ptr->center != 0.0 && + tbl_ptr->right != 0.0) { + printf(" new StrokeCharRec( %d, char%d, (float)%g, (float)%g ),\n", + strptr->n_subpaths, i, tbl_ptr->center, tbl_ptr->right); + } else { + printf(" new StrokeCharRec( 0, /* char%d */ null, (float)%g, (float)%g ),\n", + i, tbl_ptr->center, tbl_ptr->right); + } + } + printf("};\n\n"); + + printf("final static StrokeFontRec fontinfo = new StrokeFontRec( \"%s\", %d, chars, (float)%.6g, (float)%.6g );\n\n", + head.name, head.num_ch, + (double) head.top, (double) head.bottom); + printf(" static public StrokeFontRec getStrokeFontRec() {\n"); + printf(" return fontinfo;\n"); + printf(" }\n"); + printf("}\n"); // end of class + fflush(stdout); + + freeall(); +# undef BY_BYE +} + +freeall() +{ + register Path *path; + register Path_subpath *spath; + register int i, + j, + n; + + path = strokes; + for (i = 0; i < head.num_ch; i++, path++) { + n = path->n_subpaths; + if (n <= 0) + continue; + spath = path->subpaths; + for (j = 0; j < n; j++, spath++) + if (spath->pts.pt2df != NULL) + free((char *) spath->pts.pt2df); + if (path->subpaths != NULL) + free((char *) path->subpaths); + } + free(Table); + free(sp_table); + free(strokes); + if (head.properties != NULL) + free((char *) head.properties); +} + +check_nstroke() +{ + count.path++; + if (expect.path != count.path) + BYE(PATH_MISMATCH); +} + +check_npts() +{ + count.point++; + if (expect.point != count.point) + BYE(POINT_MISMATCH); +} diff --git a/gl4java/utils/glut/fonts/strokelex.l b/gl4java/utils/glut/fonts/strokelex.l new file mode 100644 index 0000000..bfde066 --- /dev/null +++ b/gl4java/utils/glut/fonts/strokelex.l @@ -0,0 +1,134 @@ +%option noyywrap + +%{ +/* $XConsortium: lex.l,v 5.4 91/08/26 10:55:26 gildea Exp $ */ + +/***************************************************************** +Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Sun Microsystems, +the X Consortium, and MIT not be used in advertising or publicity +pertaining to distribution of the software without specific, written +prior permission. + +SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT +SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + + +#include +#include +#include +#include "strokegen.h" + +#if defined(ISC) && defined(SYSV) && defined(SYSV386) && __STDC__ +extern double atof(char *); +#endif + +#ifdef FLEX_SCANNER +int yylineno; +#endif + +%} +%% +\'[^']*\' | +\"[^"]*\" return string(yytext, yyleng); +#.* ; +[ ,;\t\n]* /* natural dilimters */ ; + +[a-zA-Z][a-zA-Z0-9_.]* { + int token; + if (token = res_words(yytext)) + return token; + return string(yytext, yyleng); + } + +[+-]?[0-9]+\.?[0-9]*[eE][+-]?[0-9]+ | +[+-]?[0-9]+\.[0-9]* | +\.[0-9]+ { + yylval.dval = atof(yytext); + return REAL; + } +[+-]?[0-9]+#[0-9]+ { + return INTEGER; + } +[+-]?[0-9]+ { + yylval.ival = atoi(yytext); + return INTEGER; + } +[()] ; +[\r] ; +%% + +int +res_words(str) +char str[]; +{ + static struct res_strct { + char *word; + int token; + } res_table[] = { + {"BOTTOM", BOTTOM}, + {"CENTER", CENTER}, + {"PROPERTIES", PROPERTIES}, + {"CLOSE", CLOSE}, + {"FONTNAME", FONTNAME}, + {"INDEX", INDEX}, + {"MAGIC", MAGIC}, + {"OPEN", OPEN}, + {"RIGHT", RIGHT}, + {"STROKE", STROKE}, + {"TOP", TOP}, + {"VERTICES", VERTICES}, + {"BEARING", BEARING}, + {"L_SPACE", L_SPACE}, + {"WIDTH", WIDTH}, + {"R_SPACE", R_SPACE}, + {"NUM_CH", NUM_CH}, + {0, 0} + }; + + { + register struct res_strct *reserved; + + reserved = res_table; + + do + if (!strcmp(str, reserved->word)) + break; + while ((++reserved)->word != 0); + return reserved->token; + } +} + +int +string(str, n) +char *str; +int n; +{ + if (*str == '\"' || *str == '\'') + { + str++; + n -= 2; /* one for EOL, one for end quote */ + } + if ((yylval.cval = (char *)malloc(n+1)) != NULL) + { + strncpy(yylval.cval, str, n); + yylval.cval[n] = '\0'; + return STRING; + } + else + return 0; +} diff --git a/gl4java/utils/textures/AWTTextureLoader.java b/gl4java/utils/textures/AWTTextureLoader.java new file mode 100644 index 0000000..2df3145 --- /dev/null +++ b/gl4java/utils/textures/AWTTextureLoader.java @@ -0,0 +1,169 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +// import java.awt.Color.*; +// import java.awt.color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This Class implements the universal + * texture-loader using the AWT's standard interface ! + * + * The number of image-types depends + * on the JDK version you use ! + * + * @see TextureLoader + */ +public class AWTTextureLoader +extends TextureLoader +{ + Component comp; + + public AWTTextureLoader(Component comp, GLFunc gl, GLUFunc glu) + { + super(gl, glu); + this.comp=comp; + } + + public boolean readTexture(String fname) + { + Image img = comp.getToolkit().getImage(fname); + return readTexture(comp, img); + } + + public boolean readTexture(URL base, String uri) + { + try { + URL url = new URL (base, uri); + Image img = comp.getToolkit().getImage(url); + return readTexture(comp, img); + } catch (Exception ex) { + System.out.println("AWTTextureLoader.readTexture <"+ + base+" / "+uri+"> failed !\n"+ex); + } + return false; + } + + private boolean readTexture(Component comp, Image img) + { + try { + try { + MediaTracker tracker = new MediaTracker(comp); + tracker.addImage(img, 0); + tracker.waitForID(0); + } + catch ( Exception e ) {} + + imageWidth = img.getWidth(comp); + imageHeight = img.getHeight(comp); + /* This is Java2 only code :-( + BufferedImage image = + new BufferedImage(imageWidth, imageHeight, + BufferedImage.TYPE_INT_RGB); + + Graphics g = image.createGraphics(); + g.drawImage(img,0,0,comp); + + imageWidth = image.getWidth(); + imageHeight = image.getHeight(); + */ + + // Read entire PNG image (doesn't throw exceptions) + int[] iPixels = new int[imageWidth * imageHeight]; + + PixelGrabber pp=new PixelGrabber(img, + 0,0, + imageWidth, imageHeight, + iPixels, + 0, + imageWidth); + try + { + pp.grabPixels(); + } + catch (InterruptedException e) + { + System.err.println("interrupted waiting for pixel!"); + error=true; + return false; + } + if ((pp.getStatus() & ImageObserver.ABORT) != 0) + { + System.err.println("image fetch aborted or errored"); + error=true; + return false; + } + + /* This is Java2 only code :-( + int imagetype = image.getType(); + switch(imagetype) + { + case BufferedImage.TYPE_INT_RGB: + glFormat=GL_RGB; + break; + case BufferedImage.TYPE_INT_ARGB: + case BufferedImage.TYPE_INT_ARGB_PRE: + glFormat=GL_RGBA; + break; + default: + error=true; + System.err.println("unsupported format: "+imagetype); + return false; + }; + */ + // + // we are guessing the RGB type, + // because fetching the true type + // is Java2 only code :-( + // + glFormat=GL_RGB; + + setTextureSize(); + pixel=new byte[imageWidth * imageHeight * getComponents()]; + + int offset=0; + int aPixel; + int y_desc; + for(y_desc=imageHeight-1; y_desc>=0; y_desc--) + { + for(int x=0;x> 16) & 0xff ).byteValue(); + + // green + pixel[offset++]= + new Integer( (aPixel >> 8) & 0xff ).byteValue(); + + // blue + pixel[offset++]= + new Integer( (aPixel ) & 0xff ).byteValue(); + + // alpha + if(glFormat==GL_RGBA) + pixel[offset++]= + new Integer( (aPixel >> 24) & 0xff ).byteValue(); + } + } + + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a AWTTexture"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/IOTextureLoader.java b/gl4java/utils/textures/IOTextureLoader.java new file mode 100644 index 0000000..4b06b93 --- /dev/null +++ b/gl4java/utils/textures/IOTextureLoader.java @@ -0,0 +1,67 @@ +package gl4java.utils.textures; + +import gl4java.*; +import gl4java.utils.glut.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This abstract Class implements the + * file and url based methods "readTexture", + * to call the specialised implementation + * of the stream based "readTexture" method ! + * + * @see TextureLoader + */ +public abstract class IOTextureLoader +extends TextureLoader +{ + protected IOTextureLoader(GLFunc gl, GLUFunc glu) + { super(gl, glu); } + + public boolean readTexture(String fname) + { + boolean result = false; + InputStream is= null; + try { + is= new java.io.FileInputStream(fname); + result = readTexture(is); + } catch (Exception ex) { + System.out.println("IOTextureLoader.readTexture <"+ + fname+"> failed !\n"+ex); + } + try { + if(is!=null) is.close(); + } catch (Exception ex) {} + return result; + } + + public boolean readTexture(URL base, String uri) + { + boolean result = false; + InputStream is= null; + try { + URL url = new URL (base, uri); + URLConnection urlcon = url.openConnection(); + urlcon.setDoOutput(false); + urlcon.setDoInput(true); + is = urlcon.getInputStream(); + result = readTexture(is); + } catch (Exception ex) { + System.out.println("IOTextureLoader.readTexture <"+ + base+" / "+uri+"> failed !\n"+ex); + } + try { + if(is!=null) is.close(); + } catch (Exception ex) {} + return result; + } + + protected abstract boolean readTexture(InputStream is); +} + diff --git a/gl4java/utils/textures/PPMAsciiTextureLoader.java b/gl4java/utils/textures/PPMAsciiTextureLoader.java new file mode 100644 index 0000000..b8d1610 --- /dev/null +++ b/gl4java/utils/textures/PPMAsciiTextureLoader.java @@ -0,0 +1,88 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This is Class implements the PPM-Ascii + * texture-loader ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class PPMAsciiTextureLoader +extends IOTextureLoader +{ + public PPMAsciiTextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + protected boolean readTexture(InputStream is) + { + try { + glFormat=GL_RGB; + + DataInputStream reader = new DataInputStream ( is ); + + String lin=reader.readLine(); //P6 + String subLin=lin.substring(0,1); + + lin=reader.readLine(); + subLin=lin.substring(0,1); + + while (subLin.compareTo("#")==0) + { + lin=reader.readLine(); + subLin=lin.substring(0,1); + } + + char[] dim=lin.toCharArray(); + + int i=0; + char car=lin.charAt(i); + String blanco=new String(" "); + Character C=new Character(car); + car=C.charValue(); + while (C.isDigit(car)) + { + i++; + car=lin.charAt(i); + C=new Character(car); + } + + String alto=lin.substring(0,i); + String ancho=lin.substring(i+1,lin.length()); + + Integer hh=new Integer(alto); + imageWidth=hh.intValue(); + hh=new Integer(ancho); + imageHeight=hh.intValue(); + + pixel=new byte[imageWidth * imageHeight * getComponents()]; + + lin=reader.readLine(); //255 + + reader.read(pixel, 0, pixel.length); + + reader.close(); + setTextureSize(); + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a PPMAsciiTextureLoader"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/PngTextureLoader.java b/gl4java/utils/textures/PngTextureLoader.java new file mode 100644 index 0000000..6cc9bb2 --- /dev/null +++ b/gl4java/utils/textures/PngTextureLoader.java @@ -0,0 +1,160 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +import com.sixlegs.image.png.*; + +/** + * This is Class implements the PNG texture-loader + * while using the png-library in package + * "com.sixlegs.image.png" ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class PngTextureLoader +extends IOTextureLoader +{ + protected boolean grayToAlpha = false; + + public PngTextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + /** + * Set to 'true' to load grayscale images as alpha images + * (in other words, GL_ALPHA instead of GL_LUMINANCE) + */ + public void setGrayToAlpha(boolean b) + { + this.grayToAlpha = b; + } + + protected boolean readTexture(InputStream is) + { + try { + int len; + PngImage png = new PngImage(is); + + imageWidth = png.getWidth(); + imageHeight = png.getHeight(); + + // Read entire PNG image (doesn't throw exceptions) + int[] iPixels = new int[imageWidth * imageHeight]; + + PixelGrabber pp=new PixelGrabber(png, + 0,0, + imageWidth, imageHeight, + iPixels, + 0, + imageWidth); + try + { + pp.grabPixels(); + } + catch (InterruptedException e) + { + System.err.println("interrupted waiting for pixel!"); + error=true; + return false; + } + if ((pp.getStatus() & ImageObserver.ABORT) != 0) + { + System.err.println("image fetch aborted or errored"); + error=true; + return false; + } + + // bitDepth beachten + switch(png.getColorType()) + { + case PngImage.COLOR_TYPE_GRAY: + glFormat= grayToAlpha ? GL_ALPHA : GL_LUMINANCE; + break; + case PngImage.COLOR_TYPE_GRAY_ALPHA: + glFormat=GL_LUMINANCE_ALPHA; + break; + case PngImage.COLOR_TYPE_RGB: + glFormat=GL_RGB; + break; + case PngImage.COLOR_TYPE_RGB_ALPHA: + glFormat=GL_RGBA; + break; + case PngImage.COLOR_TYPE_PALETTE: + // todo: support COLOR_TYPE_INDEXED? + glFormat=GL_RGB; + break; + default: + error=true; + System.err.println("unsupported png color type: "+ + png.getColorType()); + return false; + }; + + int ncmpts = getComponents(); + pixel=new byte[imageWidth * imageHeight * ncmpts]; + + byte alpha=0; + byte red=0; + byte green=0; + byte blue=0; + int offset=0; + int aPixel; + for(int y=imageHeight-1; y>=0; y--) + { + for(int x=0;x>16); + pixel[offset+1] = (byte)(aPixel>>8); + pixel[offset+2] = (byte)(aPixel>>0); + pixel[offset+3] = (byte)(aPixel>>24); + offset += 4; + break; + case GL_RGB: + pixel[offset] = (byte)(aPixel>>16); + pixel[offset+1] = (byte)(aPixel>>8); + pixel[offset+2] = (byte)(aPixel>>0); + offset += 3; + break; + case GL_LUMINANCE: + case GL_COLOR_INDEX: + pixel[offset] = (byte)(aPixel); + offset += 1; + break; + case GL_LUMINANCE_ALPHA: // todo: untested + pixel[offset] = (byte)(aPixel); + pixel[offset+1] = (byte)(aPixel>>24); + offset += 2; + break; + } + + } + } + + setTextureSize(); + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a PngTexture"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/TGATextureGrabber.java b/gl4java/utils/textures/TGATextureGrabber.java new file mode 100644 index 0000000..2d1c432 --- /dev/null +++ b/gl4java/utils/textures/TGATextureGrabber.java @@ -0,0 +1,61 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.io.*; +import java.net.*; + +public class TGATextureGrabber +extends TextureGrabber +{ + public TGATextureGrabber(GLFunc gl) + { + super(gl); + } + + public boolean write2File(OutputStream os) + { + try { + DataOutputStream fout= new DataOutputStream(os); + + //write TGA header + fout.writeByte(0); //ID length, 0 because no image id field + fout.writeByte(0); //no color map + fout.writeByte(2); //image type (24 bit RGB, uncompressed) + fout.writeShort(0); //color map origin, ignore because no color map + fout.writeShort(0); //color map length, ignore because no color map + fout.writeByte(0); //color map entry size, ignore because no color map + fout.writeShort(0); //x origin + fout.writeShort(0); //y origin + short s = (short)width; + fout.writeByte((byte)(s & 0x00ff)); //image width low byte + fout.writeByte((byte)((s & 0xff00)>>8)); //image width high byte + s = (short)height; + fout.writeByte((byte)(s & 0x00ff)); //image height low byte + fout.writeByte((byte)((s & 0xff00)>>8)); //image height high byte + fout.writeByte(24); //bpp + fout.writeByte(0); //description bits + + //process image data: + // TGA pixels should be written in BGR format, + // so R en B should be switched + byte tmp; + for (int i=0; i<(width*height*3); i+=3) { + tmp=pixels[i]; + pixels[i]=pixels[i+2]; + pixels[i+2]=tmp; + } + + //write TGA image data + fout.write(pixels, 0, pixels.length); + + fout.flush(); + fout.close(); + } catch (Exception ex) { + System.out.println("TGATextureGrabber.write2File failed !\n"+ex); + return false; + } + return true; + } +} + diff --git a/gl4java/utils/textures/TGATextureLoader.java b/gl4java/utils/textures/TGATextureLoader.java new file mode 100644 index 0000000..b0c915f --- /dev/null +++ b/gl4java/utils/textures/TGATextureLoader.java @@ -0,0 +1,111 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.io.*; +import java.net.*; + +/** + * This is Class implements a TGA texture-loader ! + * At this time, this loader only supports + * loading files, which are saved with + * the TGATextureGrabber ! + * This means: 24 bpp, RGB, uncompressed, no-colormap, + * no image id-field ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class TGATextureLoader +extends IOTextureLoader +{ + public TGATextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + protected boolean readTexture(InputStream is) + { + try { + int cc; + + glFormat=GL_RGB; + + DataInputStream reader = new DataInputStream ( is ); + + //write TGA header + reader.readByte(); //ID length, 0 because no image id field + reader.readByte(); //no color map + cc = reader.readByte(); //image type (24 bit RGB, uncompressed) + if(cc!=2) + { + reader.close(); + System.out.println("TGATextureLoader: File is not 24bit RGB Data !"); + error=true; + return false; + } + reader.readShort(); //color map origin, ignore because no color map + reader.readShort(); //color map length, ignore because no color map + reader.readByte(); //color map entry size, ignore because no color map + reader.readShort(); //x origin + reader.readShort(); //y origin + + cc = reader.readByte(); // image width low byte + short s = (short)((short)cc & 0x00ff); + cc = reader.readByte(); // image width high byte + s = (short) ( (short)( ((short)cc & 0x00ff)<<8 ) | s ); + imageWidth = (int)s; + + cc = reader.readByte(); // image height low byte + s = (short)((short)cc & 0x00ff); + cc = reader.readByte(); // image height high byte + s = (short) ( (short)( ((short)cc & 0x00ff)<<8 ) | s ); + imageHeight = (int)s; + + cc=reader.readByte(); // 24bpp + if(cc!=24) + { + reader.close(); + System.out.println("TGATextureLoader: File is not 24bpp Data !"); + error=true; + return false; + } + reader.readByte(); //description bits + + if(3!=getComponents()) + { + reader.close(); + System.out.println("TGATextureLoader: Currenly only RGB (24bit) data is supported !"); + error=true; + return false; + } + + pixel=new byte[imageWidth * imageHeight * 3]; + + //read TGA image data + reader.read(pixel, 0, pixel.length); + + //process image data: + // TGA pixels should be written in BGR format, + // so R en B should be switched + byte tmp; + for (int i=0; i failed !\n"+ex); + } + return false; + } + + public boolean write2File(URL base, String uri) + { + try { + URL url = new URL (base, uri); + URLConnection urlcon = url.openConnection(); + urlcon.setDoOutput(true); + OutputStream os = urlcon.getOutputStream(); + return write2File(os); + } catch (Exception ex) { + System.out.println("TGATextureGrabber.write2File <"+ + base+" / "+uri+"> failed !\n"+ex); + } + return false; + } + + public abstract boolean write2File(OutputStream os); +} + diff --git a/gl4java/utils/textures/TextureLoader.java b/gl4java/utils/textures/TextureLoader.java new file mode 100644 index 0000000..36a8cfe --- /dev/null +++ b/gl4java/utils/textures/TextureLoader.java @@ -0,0 +1,41 @@ +package gl4java.utils.textures; + +import gl4java.*; +import gl4java.utils.glut.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This abstract Class defines the interface + * for ALL texture loaders ! + * + * @see TextureTool + * @see GLImageCanvas + */ +public abstract class TextureLoader +extends TextureTool +{ + protected TextureLoader(GLFunc gl, GLUFunc glu) + { super(gl, glu); } + + /** + * Loads an Texture + * + * @param fname The filename + */ + public abstract boolean readTexture(String fname); + + /** + * Loads an Texture + * + * @param base The base URL + * @param uri The additional uri for the base URL + */ + public abstract boolean readTexture(URL base, String uri); +} + diff --git a/gl4java/utils/textures/TextureTool.java b/gl4java/utils/textures/TextureTool.java new file mode 100755 index 0000000..a842d1f --- /dev/null +++ b/gl4java/utils/textures/TextureTool.java @@ -0,0 +1,610 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This Class implements basic functions, + * which are used by all TextureLoader implementations ! + * + * @see TextureLoader + */ +public abstract class TextureTool +implements GLEnum, GLUEnum +{ + protected GLFunc gl; + protected GLUFunc glu; + + /** + * just a default type ... + */ + protected byte[] pixel; + protected boolean pixelScaled; + + protected int imageWidth; + protected int imageHeight; + protected int textWidth; + protected int textHeight; + + protected int glFormat; + protected boolean error; + + public String toString() + { + return "Texture "+textWidth+"x"+textHeight+ + "[image "+imageWidth+"x"+imageHeight+ + "[bpc "+getComponents()+"]"+ + "]"; + } + + protected TextureTool(GLFunc gl, GLUFunc glu) + { + this.gl=gl; + this.glu=glu; + error=false; + pixelScaled = false; + } + + public final boolean isOk() { return !error; } + + public final int getGLFormat() { return glFormat; } + public int getGLBytesPerComponent() { return 1; } + public int getGLComponentFormat() { return GL_UNSIGNED_BYTE; } + + /** + * just a default for byte sized component's + */ + public int getComponents() + { + switch (glFormat) + { + case GL_RGBA: + return 4; + case GL_RGB: + return 3; + case GL_LUMINANCE_ALPHA: + return 2; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_COLOR_INDEX: + return 1; + default: + return 0; + } + } + + /** + * Dimension + */ + public final int getImageWidth() { return imageWidth; } + public final int getImageHeight() { return imageHeight; } + + public final int getTextureWidth() { return textWidth; } + public final int getTextureHeight() { return textHeight; } + + + public static final int getMaxTextureSize(GLFunc gl) + { + int[] maxSize=new int[1]; + gl.glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxSize); + return maxSize[0]; + } + + /** + * This method is called directly after loading + * the texture ! + * You normally do not need to call this method ! + * + * The textWidth/textHeight data is set correctly + * to a power of 2 ! + */ + public void setTextureSize() + { + int e_x, e_y, i; + + /* achieve the 2**e_x>=imageWidth, 2**e_y>=imageHeight */ + e_x=0; textWidth=1; + + while (textWidth "+w+"/"+h); + System.out.println("scale4Best: aspect (w/h) "+ + iaspect+" -> "+(double)w/(double)h); + */ + + /* Save current modes. */ + gl.glGetIntegerv(GL_PACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_PACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_PACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_PACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_PACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL_PACK_ALIGNMENT, alignment); + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, unswapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, unlsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, unrowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, unskiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, unskippixels); + gl.glGetIntegerv(GL_UNPACK_ALIGNMENT, unalignment); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_PACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, textWidth); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, imageWidth); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if( glu.gluScaleImage(glFormat, + imageWidth, imageHeight, + GL_UNSIGNED_BYTE, + pixel, + w, h, + GL_UNSIGNED_BYTE, + buffer)!=0 ) + { + // glu failure + error=true; + } else { + pixel = buffer; + imageWidth=w; + imageHeight=h; + } + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_PACK_ALIGNMENT, alignment[0]); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment[0]); + } + if(!error) + pixelScaled = true; + return pixelScaled; + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method calls scaleTexture2Pow2() to + * make the image of the normal texture size := pow2 ! + * Then glTexImage2D is called with the texture properties ! + * + * The Ascpect-Ratio is dropped ! + * + * @see TextureTool#scaleTexture2Pow2 + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glPixelStorei + */ + public boolean texImage2DScaled2Pow2() + { + // The Scaled Way + if(!scaleTexture2Pow2()) + return false; + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + getTexture()); // The Scaled Way + + return glutReportErrors(); + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method calls scaleTexture4BestSize() to + * make the image of the best fitting size + * relative to the texture-size! + * Then glTexImage2D is called with the texture properties ! + * + * The Ascpect-Ratio is not changed ! + * + * A fine example exists in "demos/MiscDemos/GLImageViewerWorld" ! + * + * @see TextureTool#scaleTexture4BestSize + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glPixelStorei + */ + public boolean texImage2DScaled4BestSize() + { + // The Scaled Way + if(!scaleTexture4BestSize()) + return false; + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + getTexture()); // The Scaled Way + + return glutReportErrors(); + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method creates a target texture (glTexImage2D) + * without data, + * and substitutes only the unscaled image data (glTexSubImage2D) ! + * + * The benefits of this functions is, + * that the image/texture is not scaled ! + * A fine example exists in "demos/MiscDemos/GLImageViewerCanvas" ! + * + * The pixel store mode GL_UNPACK_ALIGNMENT, + * is set temporary to byte alignment, then back to default (4) ! + * + * The pixel store mode GL_UNPACK_ROW_LENGTH, + * is set temporary to imageWidth, then back to default (0) ! + * + * @param clear if true, the texture will be initially loaded with + * a dummy blank (black) array + * + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glTexSubImage2D + * @see GLFunc#glPixelStorei + * @see GLImageCanvas + */ + public boolean texImage2DNonScaled(boolean clear) + { + int swapbytes[]={0}, lsbfirst[]={0}, rowlength[]={0}; + int skiprows[]={0}, skippixels[]={0}, alignment[]={0}; + int unswapbytes[]={0}, unlsbfirst[]={0}, unrowlength[]={0}; + int unskiprows[]={0}, unskippixels[]={0}, unalignment[]={0}; + + /* Save current modes. */ + gl.glGetIntegerv(GL_PACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_PACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_PACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_PACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_PACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL_PACK_ALIGNMENT, alignment); + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, unswapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, unlsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, unrowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, unskiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, unskippixels); + gl.glGetIntegerv(GL_UNPACK_ALIGNMENT, unalignment); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_PACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, imageWidth); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + byte[] clrPixel = null; + + if(clear) + { + clrPixel= + new byte[textWidth * textHeight * getComponents()]; + } + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + clrPixel); + + // The unscaled way + /* + System.out.println("******* width "+getImageWidth()); + System.out.println("******* height "+getImageHeight()); + System.out.println("******* format "+getGLFormat()); + System.out.println("******* comps "+getGLComponentFormat()); + System.out.println("******* text "+getTexture()); + System.out.println("******* text.length "+getTexture().length); + */ + + gl.glTexSubImage2D(GL_TEXTURE_2D, + 0, + 0, 0, + getImageWidth(), + getImageHeight(), + getGLFormat(), + getGLComponentFormat(), + getTexture()); + + // System.out.println("+++++++++"); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_PACK_ALIGNMENT, alignment[0]); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment[0]); + return glutReportErrors(); + } + + protected final boolean glutReportErrors() + { + int error; + + while ((error = gl.glGetError()) != GL_NO_ERROR) + __glutWarning("GL error: "+glu.gluErrorString(error)); + return error==GL_NO_ERROR; + } + + protected static final void __glutWarning(String str) + { + System.out.println("GLUT: Warning in (unamed): "+str+"\n"); + } +} + -- cgit v1.2.3