diff options
Diffstat (limited to 'gl4java')
65 files changed, 57269 insertions, 0 deletions
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<argList.length; i++) + args[i] = argList[i]; + + GL4JavaReflections nobj = + new GL4JavaReflections(methodClassInstance, + type, methodName, args); + + + return nobj; + } + + public String getMethodSignature() + { + return getMethodSignature(argList, type); + } + + public static String patchJvmSigType(String s) + { + if(s==null) + return null; + + if(s.startsWith("[")) + return s; + + if(s.equals("boolean")) + return "Z"; + if(s.equals("byte")) + return "B"; + if(s.equals("char")) + return "C"; + if(s.equals("short")) + return "S"; + if(s.equals("int")) + return "I"; + if(s.equals("long")) + return "J"; + if(s.equals("float")) + return "F"; + if(s.equals("double")) + return "D"; + if(s.equals("void")) + return "V"; + + return s; + } + + public static String getMethodSignature(Class[] args, Class type) + { + String res = new String(); + String helper = null; + int i,j; + + res += "("; + + for (i=0; i<args.length; i++) + { + res += patchJvmSigType(args[i].getName()); + } + res += ")"+patchJvmSigType(type.getName()); + return res; + } + + public static GL4JavaReflections findMethod(Object methodClassInstance, + String methodName, + String signature) + { + Method[] methods = null; + try { + methods = + methodClassInstance.getClass().getDeclaredMethods(); + } catch (Exception ex) { + System.out.println("ERROR: GL4JavaReflections.findMethod"); + ex.printStackTrace(); + return null; + } + + GL4JavaReflections res=null; + Method method = null; + String name = null; + Class[] args = null; + Class t = null; + + for(int i=0; i<methods.length; i++) + { + method = methods[i]; + name = method.getName(); + if(name.equals(methodName)) + { + args = method.getParameterTypes(); + t = method.getReturnType(); + if(signature==null || + signature.equals(getMethodSignature(args, t)) + ) + { + res = new GL4JavaReflections( + methodClassInstance, + method.getReturnType(), + methodName, + args); + return res; + } + } + } + System.out.println("GL4JavaReflections.findMethod: could not find method: "+methodName+" "+signature); + + return null; + } + + public static String findMethodSignature (Object methodClassInstance, + String methodName, + String signature) + { + GL4JavaReflections ref = + findMethod(methodClassInstance, methodName, signature); + if(ref==null) return null; + return ref.getMethodSignature(); + } +} + + diff --git a/gl4java/GLContext.java.skel b/gl4java/GLContext.java.skel new file mode 100644 index 0000000..c91e4f6 --- /dev/null +++ b/gl4java/GLContext.java.skel @@ -0,0 +1,2251 @@ +/** + * @(#) GLContext.java + */ + + +package gl4java; + +import gl4java.jau.awt.WinHandleAccess; + +import java.awt.*; +import java.applet.Applet; +import java.awt.event.*; +import java.lang.reflect.*; + +/** + * The base manager class for the OpenGL language mapping for Java ! + * + * <p> + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * All native libraries and GLFunc* and GLUFunc* implementations + * can/should be loaded right here ! + * + * <pre> + <a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a> + <a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a> + <a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a> + <p> + To check the library versions, you can start the + <a href="GLContext.html#main(java.lang.String[])">main</a> + function with <code>java gl4java.GLContext</code> + * </pre> + * + * <p> + * + * This class creates a GLContext in the constructor which fits to the native Window + * of the given Component ! + * + * <pre> + <a href="GLContext.html#GLContext(java.awt.Component, gl4java.GLFunc, gl4java.GLUFunc> + * </pre> + * + * <p> + * + * If you want to port any OpenGL program to GL4Java, + * you can use 'glc2glj'. This easy kornshell-sed script converts + * many types and Math function calls ;-). E.g.: All C double constant literals + * will be changed to floats (0.0 -> 0.0f) and all sin, cos, .. functions + * will get the '(float)Math.' prefix ! + * + * <pre> + <a href="../../../demos/glc2glj">glc2glj - A simple c to java converter for C- and GL-types</a> + * </pre> + * <p> + * + * The native libraries are plattform depended. + * + * <pre> + The default native library for Win32 and Unice's is : + <p> + GLContext: GL4JavaJauGljJNI + GLFuncJauJNI: GL4JavaJauGLJNI + GLUFuncJauJNI: GL4JavaJauGLUJNI + <p> + Note: + <p> + The default native library for Macintosh is : + <p> + GLContext: GL4JavaMacGZGljJNI + GLFuncJauJNI: GL4JavaMacGZGLJNI + GLUFuncJauJNI: GL4JavaMacGZGLUJNI + <p> + <p> + To check wich version and vendors are currently used, + just call while a GLContext is created : + <p> + <a href="GLContext.html#gljShowVersions()">gljShowVersions</a> + <p> + Where an own Frame is opened ! + * </pre> + * + * 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 ! + * + * <p> + * + * To have a convinient usage, e.g. automatic resizing, GLContext + * and painting/gl-rendering, some classes in the package gl4java.awt + * may help you. + * + * <pre> + E.g.: <a href="awt/GLCanvas.html">gl4java.awt.GLCanvas</a> + <p> + <a href="awt/GLCanvas.html#init()">init</a> to create the java-stuff and GL-inits + <a href="awt/GLCanvas.html#display()">display</a> to render one frame, called by paint + <a href="awt/GLCanvas.html#reshape(int, int)">reshape</a> to reshape (window resize) + <p> + Or look for animation at + <a href="awt/GLAnimCanvas.html">gl4java.awt.GLAnimCanvas</a> ! + * </pre> + * + * <p> + * + * IF you remove/release a The component which is binded to this GLContext, + * you have to release the GLContext also - while calling: + * + * <pre> + <a href="GLContext.html#gljDestroy()">gljDestroy</a> + * </pre> + * + * before releasing/dispose it�s Window ! + * + * <p> + * + * We also define our own OpenGL extension. This extension functions + * start with the prefix glj like you can see here: + * + * <pre> + THIS FUNCTIONS ARE FOR USERS PURPOSES: + ====================================== + + <a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a> + <a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a> + <a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a> + <a href="GLContext.html#gljGetNativeLibVersion()">gljGetNativeLibVersion</a> + <a href="GLContext.html#gljGetClassVersion()">gljGetClassVersion</a> + <a href="GLContext.html#gljShowVersions()">gljShowVersions</a> + <a href="GLContext.html#gljCheckGL()">gljCheckGL</a> + <a href="GLContext.html#gljCheckGLTypes()">gljCheckGLTypes</a> + <a href="GLContext.html#gljResize(int, int)">gljResize</a> + <a href="GLContext.html#gljSwap()">gljSwap</a> + <a href="GLContext.html#gljIsInit()">gljIsInit</a> + <a href="GLContext.html#gljMakeCurrent(boolean)">gljMakeCurrent</a> + <a href="GLContext.html#gljDestroy()">gljDestroy</a> + <a href="GLContext.html#gljFree()">gljFree</a> + + * </pre> + * <p> + * + * You can see our example demo sources: + * <pre> + <a href="../../../demos/olympicCvs.java">olympicCvs.java as java source</a> + <a href="../../../demos/glLogoCvs.java">glLogoCvs.java as java source</a> + <a href="../../../demos/glDemosCvs.java">glDemosCvs.java as java source</a> + * </pre> + * <p> + * + * If you are interessting in further Documentation, downloading the latest + * version, and/or the history of GL4Java click on the following link. + * + * <pre> + <a href="http://www.jausoft.com/gl4java.html">The GL4Java Homepage</a> + * </pre> + * <p> + * + * @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 + * + * <Major>.<Minor>.<BugFix>.<Release> + * + * Each <Value> 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<i0 && i0<i1 ) + { + strhlp = jvmVersion.substring(i0,i1); + try { + jvmVersionMinor = Integer.valueOf(strhlp).intValue(); + } catch (Exception e) + {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");} + } + + if(gljClassDebug) + { + System.out.println("jvm version (parsed): "+ + "major: "+jvmVersionMajor+ + ", minor: "+jvmVersionMinor); + } + + isNetscapeJvm = jvmVendor!=null && jvmVendor.indexOf("Netscape")>=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<libNames.length; libNumber++) + libLoaded[libNumber]=false; + + for(libNumber=0; libNumber<libNames.length; libNumber++) + { + do { + try { + System.loadLibrary( libNames[libNumber] ); + libLoaded[libNumber]=true; + if(gljClassDebug) + { + System.out.println("loaded native library: "+ + libNames[libNumber]); + } + } catch ( UnsatisfiedLinkError e) { + System.out.println + ( "Sorry, can't find the library: "+ + libNames[libNumber]+"\n"+e ); + + libNames[libNumber]=null; // stop trying ... :-( + } + } while( libLoaded[libNumber]==false && + libNames[libNumber]!=null ); + } + + for(libNumber=0; libNumber<libNames.length; libNumber++) + { + if(libLoaded[libNumber]==false) break; + } + if(libNumber==libNames.length) + { + libsLoaded=true; + } + + return libsLoaded; + } + + /** + * no no no .. the user has to choose ! + * + * The user must call loadNativeLibrary ! + * + * @see GLContext#loadNativeLibrary + * + * static { + * if(!libLoaded) + * loadNativeLibrares(null, null, null); + * } + */ + + /** + * 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 <glj-libname> gl4java-glj-lib native library + * -gllib <gl-libname> gl4java-gl-lib native library + * -glulib <glu-libname> gl4java-glu-lib native library + * -glclass <gl-class> gl4java-gl-class java GLFunc implementation + * -gluclass <glu-class> 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 <options>, where options can be: "); + System.out.println(" -gljlib <glj-libname> \t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib <gl-libname> \t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib <glu-libname> \t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass <gl-class> \t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass <glu-class> \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) ! + * + * <p> + * + * The user can use this method to check if he can start rendering + * and to be sure his initialisation (init) is done ! + * + * <p> + * + * If you use gl4java.awt.GLCanvas, you should use the cvsIsInit + * method ! + * <p> + * + * @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<GLFunc.GL_PROC_NAMES.length; i++) + { + h=GLFunc.GL_PROC_NAMES[i]; + if(h==null) break; + + if(gljTestGLProc (h, verbose)) + tmp= "OK : "+h+"\n"; + else + tmp= "NOPE: "+h+"\n"; + + info3 += tmp; + } + + return info1+"\n"+info2+"\n"+info3; + } + + /** + * function to show complete version info into an extra Frame + * + * Be sure that the native library must be loaded ! + */ + public final Frame gljShowVersions() + { + Frame f = new Frame("GL4Java Version"); + TextArea info= new TextArea(25, 80); + info.setEditable(false); + f.add(info); + f.setSize(600, 400); + + f.pack(); + f.setVisible(true); + + String str = "null string"; + if( gljMakeCurrent(true) == false ) + { + str="problem in use() method\n"; + } else { + str=gljGetVersions(gljNativeDebug); + if(str==null) + str="could not get versions"; + System.out.println(str); + gljFree(); + } + info.append(str); + + f.addWindowListener + ( new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + // button window menu ... :-) + e.getWindow().dispose(); + } + } + ); + + return f; + } + +} + diff --git a/gl4java/GLEnum.java b/gl4java/GLEnum.java new file mode 100644 index 0000000..b331159 --- /dev/null +++ b/gl4java/GLEnum.java @@ -0,0 +1,1347 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLEnum.java + */ + + +package gl4java; + +/** + * The base interface for OpenGL enumerates, + * which provides you all the C-API style enumerates + * + * @version 2.01, 15. November 1999 + * @author Sven Goethel + */ +public interface GLEnum +{ + + public static final boolean GL_FALSE = false; + public static final boolean GL_TRUE = true; + +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: gl-enum-auto.orig . . . + * Destination-Class: gl4java_GLEnum ! + */ + + public static final int GL_1PASS_ARB = 0x80A1; + public static final int GL_1PASS_SGIS = 0x80A1; + public static final int GL_2D = 0x0600; + public static final int GL_2PASS_0_ARB = 0x80A2; + public static final int GL_2PASS_0_SGIS = 0x80A2; + public static final int GL_2PASS_1_ARB = 0x80A3; + public static final int GL_2PASS_1_SGIS = 0x80A3; + public static final int GL_2_BYTES = 0x1407; + public static final int GL_3D = 0x0601; + public static final int GL_3D_COLOR = 0x0602; + public static final int GL_3D_COLOR_TEXTURE = 0x0603; + public static final int GL_3_BYTES = 0x1408; + public static final int GL_422_AVERAGE_EXT = 0x80CE; + public static final int GL_422_EXT = 0x80CC; + public static final int GL_422_REV_AVERAGE_EXT = 0x80CF; + public static final int GL_422_REV_EXT = 0x80CD; + public static final int GL_4D_COLOR_TEXTURE = 0x0604; + public static final int GL_4PASS_0_ARB = 0x80A4; + public static final int GL_4PASS_0_SGIS = 0x80A4; + public static final int GL_4PASS_1_ARB = 0x80A5; + public static final int GL_4PASS_1_SGIS = 0x80A5; + public static final int GL_4PASS_2_ARB = 0x80A6; + public static final int GL_4PASS_2_SGIS = 0x80A6; + public static final int GL_4PASS_3_ARB = 0x80A7; + public static final int GL_4PASS_3_SGIS = 0x80A7; + public static final int GL_4_BYTES = 0x1409; + public static final int GL_ABGR_EXT = 0x8000; + public static final int GL_ACCUM = 0x0100; + public static final int GL_ACCUM_ALPHA_BITS = 0x0D5B; + public static final int GL_ACCUM_BLUE_BITS = 0x0D5A; + public static final int GL_ACCUM_BUFFER_BIT = 0x00000200; + public static final int GL_ACCUM_CLEAR_VALUE = 0x0B80; + public static final int GL_ACCUM_GREEN_BITS = 0x0D59; + public static final int GL_ACCUM_RED_BITS = 0x0D58; + public static final int GL_ACTIVE_TEXTURE_ARB = 0x84E0; + public static final int GL_ADD = 0x0104; + public static final int GL_ADD_SIGNED_EXT = 0x8574; + public static final int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; + public static final int GL_ALIASED_POINT_SIZE_RANGE = 0x846D; + public static final int GL_ALLOW_DRAW_FRG_HINT_PGI = 107024; + public static final int GL_ALLOW_DRAW_MEM_HINT_PGI = 107025; + public static final int GL_ALLOW_DRAW_OBJ_HINT_PGI = 107022; + public static final int GL_ALLOW_DRAW_WIN_HINT_PGI = 107023; + public static final int GL_ALL_ATTRIB_BITS = 0x000FFFFF; + public static final int GL_ALL_STATIC_DATA_IBM = 0x19294; + public static final int GL_ALPHA = 0x1906; + public static final int GL_ALPHA12 = 0x803D; + public static final int GL_ALPHA12_EXT = 0x803D; + public static final int GL_ALPHA16 = 0x803E; + public static final int GL_ALPHA16_EXT = 0x803E; + public static final int GL_ALPHA4 = 0x803B; + public static final int GL_ALPHA4_EXT = 0x803B; + public static final int GL_ALPHA8 = 0x803C; + public static final int GL_ALPHA8_EXT = 0x803C; + public static final int GL_ALPHA_BIAS = 0x0D1D; + public static final int GL_ALPHA_BITS = 0x0D55; + public static final int GL_ALPHA_MAX_CLAMP_INGR = 0x8567; + public static final int GL_ALPHA_MIN_CLAMP_INGR = 0x8563; + public static final int GL_ALPHA_SCALE = 0x0D1C; + public static final int GL_ALPHA_TEST = 0x0BC0; + public static final int GL_ALPHA_TEST_FUNC = 0x0BC1; + public static final int GL_ALPHA_TEST_REF = 0x0BC2; + public static final int GL_ALWAYS = 0x0207; + public static final int GL_ALWAYS_FAST_HINT_PGI = 107020; + public static final int GL_ALWAYS_SOFT_HINT_PGI = 107021; + public static final int GL_AMBIENT = 0x1200; + public static final int GL_AMBIENT_AND_DIFFUSE = 0x1602; + public static final int GL_AND = 0x1501; + public static final int GL_AND_INVERTED = 0x1504; + public static final int GL_AND_REVERSE = 0x1502; + public static final int GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9; + public static final int GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8; + public static final int GL_ATTENUATION_EXT = 0x834D; + public static final int GL_ATTRIB_STACK_DEPTH = 0x0BB0; + public static final int GL_AUTO_NORMAL = 0x0D80; + public static final int GL_AUX0 = 0x0409; + public static final int GL_AUX1 = 0x040A; + public static final int GL_AUX2 = 0x040B; + public static final int GL_AUX3 = 0x040C; + public static final int GL_AUX_BUFFERS = 0x0C00; + public static final int GL_AVERAGE_EXT = 0x8335; + public static final int GL_BACK = 0x0405; + public static final int GL_BACK_LEFT = 0x0402; + public static final int GL_BACK_NORMALS_HINT_PGI = 107043; + public static final int GL_BACK_RIGHT = 0x0403; + public static final int GL_BGR = 0x80E0; + public static final int GL_BGRA = 0x80E1; + public static final int GL_BGRA_EXT = 0x80E1; + public static final int GL_BGR_EXT = 0x80E0; + public static final int GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541; + public static final int GL_BINORMAL_ARRAY_EXT = 0x843A; + public static final int GL_BINORMAL_ARRAY_POINTER_EXT = 0x8443; + public static final int GL_BINORMAL_ARRAY_STRIDE_EXT = 0x8441; + public static final int GL_BINORMAL_ARRAY_TYPE_EXT = 0x8440; + public static final int GL_BITMAP = 0x1A00; + public static final int GL_BITMAP_TOKEN = 0x0704; + public static final int GL_BLEND = 0x0BE2; + public static final int GL_BLEND_COLOR_EXT = 0x8005; + public static final int GL_BLEND_DST = 0x0BE0; + public static final int GL_BLEND_DST_ALPHA_EXT = 0x80CA; + public static final int GL_BLEND_DST_ALPHA_INGR = 0x80CA; + public static final int GL_BLEND_DST_RGB_EXT = 0x80C8; + public static final int GL_BLEND_DST_RGB_INGR = 0x80C8; + public static final int GL_BLEND_EQUATION = 0x8009; + public static final int GL_BLEND_EQUATION_EXT = 0x8009; + public static final int GL_BLEND_SRC = 0x0BE1; + public static final int GL_BLEND_SRC_ALPHA_EXT = 0x80CB; + public static final int GL_BLEND_SRC_ALPHA_INGR = 0x80CB; + public static final int GL_BLEND_SRC_RGB_EXT = 0x80C9; + public static final int GL_BLEND_SRC_RGB_INGR = 0x80C9; + public static final int GL_BLUE = 0x1905; + public static final int GL_BLUE_BIAS = 0x0D1B; + public static final int GL_BLUE_BITS = 0x0D54; + public static final int GL_BLUE_MAX_CLAMP_INGR = 0x8566; + public static final int GL_BLUE_MIN_CLAMP_INGR = 0x8562; + public static final int GL_BLUE_SCALE = 0x0D1A; + public static final int GL_BYTE = 0x1400; + public static final int GL_C3F_V3F = 0x2A24; + public static final int GL_C4F_N3F_V3F = 0x2A26; + public static final int GL_C4UB_V2F = 0x2A22; + public static final int GL_C4UB_V3F = 0x2A23; + public static final int GL_CCW = 0x0901; + public static final int GL_CLAMP = 0x2900; + public static final int GL_CLAMP_TO_BORDER_SGIS = 0x812D; + public static final int GL_CLAMP_TO_EDGE = 0x812F; + public static final int GL_CLAMP_TO_EDGE_SGIS = 0x812F; + public static final int GL_CLEAR = 0x1500; + public static final int GL_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1; + public static final int GL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF; + public static final int GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1; + public static final int GL_CLIENT_PIXEL_STORE_BIT = 0x00000001; + public static final int GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002; + public static final int GL_CLIP_FAR_HINT_PGI = 107041; + public static final int GL_CLIP_NEAR_HINT_PGI = 107040; + public static final int GL_CLIP_PLANE0 = 0x3000; + public static final int GL_CLIP_PLANE1 = 0x3001; + public static final int GL_CLIP_PLANE2 = 0x3002; + public static final int GL_CLIP_PLANE3 = 0x3003; + public static final int GL_CLIP_PLANE4 = 0x3004; + public static final int GL_CLIP_PLANE5 = 0x3005; + public static final int GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F; + public static final int GL_CMYKA_EXT = 0x800D; + public static final int GL_CMYK_EXT = 0x800C; + public static final int GL_COEFF = 0x0A00; + public static final int GL_COLOR = 0x1800; + public static final int GL_COLOR_ARRAY = 0x8076; + public static final int GL_COLOR_ARRAY_COUNT_EXT = 0x8084; + public static final int GL_COLOR_ARRAY_EXT = 0x8076; + public static final int GL_COLOR_ARRAY_POINTER = 0x8090; + public static final int GL_COLOR_ARRAY_POINTER_EXT = 0x8090; + public static final int GL_COLOR_ARRAY_SIZE = 0x8081; + public static final int GL_COLOR_ARRAY_SIZE_EXT = 0x8081; + public static final int GL_COLOR_ARRAY_STRIDE = 0x8083; + public static final int GL_COLOR_ARRAY_STRIDE_EXT = 0x8083; + public static final int GL_COLOR_ARRAY_TYPE = 0x8082; + public static final int GL_COLOR_ARRAY_TYPE_EXT = 0x8082; + public static final int GL_COLOR_BUFFER_BIT = 0x00004000; + public static final int GL_COLOR_CLEAR_VALUE = 0x0C22; + public static final int GL_COLOR_INDEX = 0x1900; + public static final int GL_COLOR_INDEX12_EXT = 0x80E6; + public static final int GL_COLOR_INDEX16_EXT = 0x80E7; + public static final int GL_COLOR_INDEX1_EXT = 0x80E2; + public static final int GL_COLOR_INDEX2_EXT = 0x80E3; + public static final int GL_COLOR_INDEX4_EXT = 0x80E4; + public static final int GL_COLOR_INDEX8_EXT = 0x80E5; + public static final int GL_COLOR_INDEXES = 0x1603; + public static final int GL_COLOR_LOGIC_OP = 0x0BF2; + public static final int GL_COLOR_MATERIAL = 0x0B57; + public static final int GL_COLOR_MATERIAL_FACE = 0x0B55; + public static final int GL_COLOR_MATERIAL_PARAMETER = 0x0B56; + public static final int GL_COLOR_MATRIX = 0x80B1; + public static final int GL_COLOR_MATRIX_SGI = 0x80B1; + public static final int GL_COLOR_MATRIX_STACK_DEPTH = 0x80B2; + public static final int GL_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2; + public static final int GL_COLOR_SUM_CLAMP_NV = 0x854F; + public static final int GL_COLOR_SUM_EXT = 0x8458; + public static final int GL_COLOR_TABLE = 0x80D0; + public static final int GL_COLOR_TABLE_ALPHA_SIZE = 0x80DD; + public static final int GL_COLOR_TABLE_ALPHA_SIZE_EXT = 0x80DD; + public static final int GL_COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD; + public static final int GL_COLOR_TABLE_BIAS = 0x80D7; + public static final int GL_COLOR_TABLE_BIAS_SGI = 0x80D7; + public static final int GL_COLOR_TABLE_BLUE_SIZE = 0x80DC; + public static final int GL_COLOR_TABLE_BLUE_SIZE_EXT = 0x80DC; + public static final int GL_COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC; + public static final int GL_COLOR_TABLE_FORMAT = 0x80D8; + public static final int GL_COLOR_TABLE_FORMAT_EXT = 0x80D8; + public static final int GL_COLOR_TABLE_FORMAT_SGI = 0x80D8; + public static final int GL_COLOR_TABLE_GREEN_SIZE = 0x80DB; + public static final int GL_COLOR_TABLE_GREEN_SIZE_EXT = 0x80DB; + public static final int GL_COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB; + public static final int GL_COLOR_TABLE_INTENSITY_SIZE = 0x80DF; + public static final int GL_COLOR_TABLE_INTENSITY_SIZE_EXT = 0x80DF; + public static final int GL_COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF; + public static final int GL_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE; + public static final int GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = 0x80DE; + public static final int GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE; + public static final int GL_COLOR_TABLE_RED_SIZE = 0x80DA; + public static final int GL_COLOR_TABLE_RED_SIZE_EXT = 0x80DA; + public static final int GL_COLOR_TABLE_RED_SIZE_SGI = 0x80DA; + public static final int GL_COLOR_TABLE_SCALE = 0x80D6; + public static final int GL_COLOR_TABLE_SCALE_SGI = 0x80D6; + public static final int GL_COLOR_TABLE_SGI = 0x80D0; + public static final int GL_COLOR_TABLE_SGI_80BC = 0x80BC; + public static final int GL_COLOR_TABLE_WIDTH = 0x80D9; + public static final int GL_COLOR_TABLE_WIDTH_EXT = 0x80D9; + public static final int GL_COLOR_TABLE_WIDTH_SGI = 0x80D9; + public static final int GL_COLOR_WRITEMASK = 0x0C23; + public static final int GL_COMBINE4_NV = 0x8503; + public static final int GL_COMBINER0_NV = 0x8550; + public static final int GL_COMBINER1_NV = 0x8551; + public static final int GL_COMBINER2_NV = 0x8552; + public static final int GL_COMBINER3_NV = 0x8553; + public static final int GL_COMBINER4_NV = 0x8554; + public static final int GL_COMBINER5_NV = 0x8555; + public static final int GL_COMBINER6_NV = 0x8556; + public static final int GL_COMBINER7_NV = 0x8557; + public static final int GL_COMBINER_AB_DOT_PRODUCT_NV = 0x8545; + public static final int GL_COMBINER_AB_OUTPUT_NV = 0x854A; + public static final int GL_COMBINER_BIAS_NV = 0x8549; + public static final int GL_COMBINER_CD_DOT_PRODUCT_NV = 0x8546; + public static final int GL_COMBINER_CD_OUTPUT_NV = 0x854B; + public static final int GL_COMBINER_COMPONENT_USAGE_NV = 0x8544; + public static final int GL_COMBINER_INPUT_NV = 0x8542; + public static final int GL_COMBINER_MAPPING_NV = 0x8543; + public static final int GL_COMBINER_MUX_SUM_NV = 0x8547; + public static final int GL_COMBINER_SCALE_NV = 0x8548; + public static final int GL_COMBINER_SUM_OUTPUT_NV = 0x854C; + public static final int GL_COMBINE_ALPHA_EXT = 0x8572; + public static final int GL_COMBINE_EXT = 0x8570; + public static final int GL_COMBINE_RGB_EXT = 0x8571; + public static final int GL_COMPILE = 0x1300; + public static final int GL_COMPILE_AND_EXECUTE = 0x1301; + public static final int GL_COMPRESSED_ALPHA_ARB = 0x84E9; + public static final int GL_COMPRESSED_INTENSITY_ARB = 0x84EC; + public static final int GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB; + public static final int GL_COMPRESSED_LUMINANCE_ARB = 0x84EA; + public static final int GL_COMPRESSED_RGBA_ARB = 0x84EE; + public static final int GL_COMPRESSED_RGB_ARB = 0x84ED; + public static final int GL_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3; + public static final int GL_CONSERVE_MEMORY_HINT_PGI = 107005; + public static final int GL_CONSTANT_ALPHA = 0x8003; + public static final int GL_CONSTANT_ALPHA_EXT = 0x8003; + public static final int GL_CONSTANT_ATTENUATION = 0x1207; + public static final int GL_CONSTANT_BORDER = 0x8151; + public static final int GL_CONSTANT_COLOR = 0x8001; + public static final int GL_CONSTANT_COLOR0_NV = 0x852A; + public static final int GL_CONSTANT_COLOR1_NV = 0x852B; + public static final int GL_CONSTANT_COLOR_EXT = 0x8001; + public static final int GL_CONSTANT_EXT = 0x8576; + public static final int GL_CONVOLUTION_1D = 0x8010; + public static final int GL_CONVOLUTION_1D_EXT = 0x8010; + public static final int GL_CONVOLUTION_2D = 0x8011; + public static final int GL_CONVOLUTION_2D_EXT = 0x8011; + public static final int GL_CONVOLUTION_BORDER_COLOR = 0x8154; + public static final int GL_CONVOLUTION_BORDER_MODE = 0x8013; + public static final int GL_CONVOLUTION_BORDER_MODE_EXT = 0x8013; + public static final int GL_CONVOLUTION_FILTER_BIAS = 0x8015; + public static final int GL_CONVOLUTION_FILTER_BIAS_EXT = 0x8015; + public static final int GL_CONVOLUTION_FILTER_SCALE = 0x8014; + public static final int GL_CONVOLUTION_FILTER_SCALE_EXT = 0x8014; + public static final int GL_CONVOLUTION_FORMAT = 0x8017; + public static final int GL_CONVOLUTION_FORMAT_EXT = 0x8017; + public static final int GL_CONVOLUTION_HEIGHT = 0x8019; + public static final int GL_CONVOLUTION_HEIGHT_EXT = 0x8019; + public static final int GL_CONVOLUTION_WIDTH = 0x8018; + public static final int GL_CONVOLUTION_WIDTH_EXT = 0x8018; + public static final int GL_COPY = 0x1503; + public static final int GL_COPY_INVERTED = 0x150C; + public static final int GL_COPY_PIXEL_TOKEN = 0x0706; + public static final int GL_CUBIC_EXT = 0x8334; + public static final int GL_CULL_FACE = 0x0B44; + public static final int GL_CULL_FACE_MODE = 0x0B45; + public static final int GL_CULL_VERTEX_EXT = 0x81AA; + public static final int GL_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB; + public static final int GL_CULL_VERTEX_IBM = 0x1928A; + public static final int GL_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC; + public static final int GL_CURRENT_BINORMAL_EXT = 0x843C; + public static final int GL_CURRENT_BIT = 0x00000001; + public static final int GL_CURRENT_COLOR = 0x0B00; + public static final int GL_CURRENT_FOG_COORDINATE_EXT = 0x8453; + public static final int GL_CURRENT_INDEX = 0x0B01; + public static final int GL_CURRENT_NORMAL = 0x0B02; + public static final int GL_CURRENT_RASTER_COLOR = 0x0B04; + public static final int GL_CURRENT_RASTER_DISTANCE = 0x0B09; + public static final int GL_CURRENT_RASTER_INDEX = 0x0B05; + public static final int GL_CURRENT_RASTER_POSITION = 0x0B07; + public static final int GL_CURRENT_RASTER_POSITION_VALID = 0x0B08; + public static final int GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06; + public static final int GL_CURRENT_SECONDARY_COLOR_EXT = 0x8459; + public static final int GL_CURRENT_TANGENT_EXT = 0x843B; + public static final int GL_CURRENT_TEXTURE_COORDS = 0x0B03; + public static final int GL_CURRENT_VERTEX_WEIGHT_EXT = 0x850B; + public static final int GL_CW = 0x0900; + public static final int GL_DECAL = 0x2101; + public static final int GL_DECR = 0x1E03; + public static final int GL_DECR_WRAP_EXT = 0x8508; + public static final int GL_DEPTH = 0x1801; + public static final int GL_DEPTH_BIAS = 0x0D1F; + public static final int GL_DEPTH_BITS = 0x0D56; + public static final int GL_DEPTH_BUFFER_BIT = 0x00000100; + public static final int GL_DEPTH_CLEAR_VALUE = 0x0B73; + public static final int GL_DEPTH_COMPONENT = 0x1902; + public static final int GL_DEPTH_COMPONENT16_SGIX = 0x81A5; + public static final int GL_DEPTH_COMPONENT24_SGIX = 0x81A6; + public static final int GL_DEPTH_COMPONENT32_SGIX = 0x81A7; + public static final int GL_DEPTH_FUNC = 0x0B74; + public static final int GL_DEPTH_RANGE = 0x0B70; + public static final int GL_DEPTH_SCALE = 0x0D1E; + public static final int GL_DEPTH_TEST = 0x0B71; + public static final int GL_DEPTH_WRITEMASK = 0x0B72; + public static final int GL_DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096; + public static final int GL_DETAIL_TEXTURE_2D_SGIS = 0x8095; + public static final int GL_DETAIL_TEXTURE_LEVEL_SGIS = 0x809A; + public static final int GL_DETAIL_TEXTURE_MODE_SGIS = 0x809B; + public static final int GL_DIFFUSE = 0x1201; + public static final int GL_DISCARD_NV = 0x8530; + public static final int GL_DISTANCE_ATTENUATION_EXT = 0x8129; + public static final int GL_DITHER = 0x0BD0; + public static final int GL_DOMAIN = 0x0A02; + public static final int GL_DONT_CARE = 0x1100; + public static final int GL_DOUBLE = 0x140A; + public static final int GL_DOUBLEBUFFER = 0x0C32; + public static final int GL_DRAW_BUFFER = 0x0C01; + public static final int GL_DRAW_PIXEL_TOKEN = 0x0705; + public static final int GL_DST_ALPHA = 0x0304; + public static final int GL_DST_COLOR = 0x0306; + public static final int GL_DUAL_ALPHA12_SGIS = 0x8112; + public static final int GL_DUAL_ALPHA16_SGIS = 0x8113; + public static final int GL_DUAL_ALPHA4_SGIS = 0x8110; + public static final int GL_DUAL_ALPHA8_SGIS = 0x8111; + public static final int GL_DUAL_INTENSITY12_SGIS = 0x811A; + public static final int GL_DUAL_INTENSITY16_SGIS = 0x811B; + public static final int GL_DUAL_INTENSITY4_SGIS = 0x8118; + public static final int GL_DUAL_INTENSITY8_SGIS = 0x8119; + public static final int GL_DUAL_LUMINANCE12_SGIS = 0x8116; + public static final int GL_DUAL_LUMINANCE16_SGIS = 0x8117; + public static final int GL_DUAL_LUMINANCE4_SGIS = 0x8114; + public static final int GL_DUAL_LUMINANCE8_SGIS = 0x8115; + public static final int GL_DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C; + public static final int GL_DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D; + public static final int GL_DUAL_TEXTURE_SELECT_SGIS = 0x8124; + public static final int GL_EDGE_FLAG = 0x0B43; + public static final int GL_EDGE_FLAG_ARRAY = 0x8079; + public static final int GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D; + public static final int GL_EDGE_FLAG_ARRAY_EXT = 0x8079; + public static final int GL_EDGE_FLAG_ARRAY_POINTER = 0x8093; + public static final int GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093; + public static final int GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C; + public static final int GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C; + public static final int GL_EMBOSS_CONSTANT_NV = 0x855E; + public static final int GL_EMBOSS_LIGHT_NV = 0x855D; + public static final int GL_EMBOSS_MAP_NV = 0x855F; + public static final int GL_EMISSION = 0x1600; + public static final int GL_ENABLE_BIT = 0x00002000; + public static final int GL_EQUAL = 0x0202; + public static final int GL_EQUIV = 0x1509; + public static final int GL_EVAL_BIT = 0x00010000; + public static final int GL_EXP = 0x0800; + public static final int GL_EXP2 = 0x0801; + public static final int GL_EXPAND_NEGATE_NV = 0x8539; + public static final int GL_EXPAND_NORMAL_NV = 0x8538; + public static final int GL_EXTENSIONS = 0x1F03; + public static final int GL_EYE_LINEAR = 0x2400; + public static final int GL_EYE_PLANE = 0x2502; + public static final int GL_EYE_PLANE_ABSOLUTE_NV = 0x855C; + public static final int GL_EYE_RADIAL_NV = 0x855B; + public static final int GL_E_TIMES_F_NV = 0x8531; + public static final int GL_FASTEST = 0x1101; + public static final int GL_FEEDBACK = 0x1C01; + public static final int GL_FEEDBACK_BUFFER_POINTER = 0x0DF0; + public static final int GL_FEEDBACK_BUFFER_SIZE = 0x0DF1; + public static final int GL_FEEDBACK_BUFFER_TYPE = 0x0DF2; + public static final int GL_FILL = 0x1B02; + public static final int GL_FILTER4_SGIS = 0x8146; + public static final int GL_FLAT = 0x1D00; + public static final int GL_FLOAT = 0x1406; + public static final int GL_FOG = 0x0B60; + public static final int GL_FOG_BIT = 0x00000080; + public static final int GL_FOG_COLOR = 0x0B66; + public static final int GL_FOG_COORDINATE_ARRAY_EXT = 0x8457; + public static final int GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456; + public static final int GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455; + public static final int GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454; + public static final int GL_FOG_COORDINATE_EXT = 0x8451; + public static final int GL_FOG_COORDINATE_SOURCE_EXT = 0x8450; + public static final int GL_FOG_DENSITY = 0x0B62; + public static final int GL_FOG_DISTANCE_MODE_NV = 0x855A; + public static final int GL_FOG_END = 0x0B64; + public static final int GL_FOG_FUNC_POINTS_SGIS = 0x812B; + public static final int GL_FOG_FUNC_SGIS = 0x812A; + public static final int GL_FOG_HINT = 0x0C54; + public static final int GL_FOG_INDEX = 0x0B61; + public static final int GL_FOG_MODE = 0x0B65; + public static final int GL_FOG_OFFSET_SGIX = 0x8198; + public static final int GL_FOG_OFFSET_VALUE_SGIX = 0x8199; + public static final int GL_FOG_SPECULAR_TEXTURE_WIN = 0x80EC; + public static final int GL_FOG_START = 0x0B63; + public static final int GL_FRAGMENT_COLOR_EXT = 0x834C; + public static final int GL_FRAGMENT_DEPTH_EXT = 0x8452; + public static final int GL_FRAGMENT_DEPTH_EXT_834B = 0x834B; + public static final int GL_FRAGMENT_MATERIAL_EXT = 0x8349; + public static final int GL_FRAGMENT_NORMAL_EXT = 0x834A; + public static final int GL_FRAMEZOOM_FACTOR_SGIX = 0x818C; + public static final int GL_FRAMEZOOM_SGIX = 0x818B; + public static final int GL_FRONT = 0x0404; + public static final int GL_FRONT_AND_BACK = 0x0408; + public static final int GL_FRONT_FACE = 0x0B46; + public static final int GL_FRONT_LEFT = 0x0400; + public static final int GL_FRONT_RIGHT = 0x0401; + public static final int GL_FULL_STIPPLE_HINT_PGI = 107033; + public static final int GL_FUNC_ADD = 0x8006; + public static final int GL_FUNC_ADD_EXT = 0x8006; + public static final int GL_FUNC_REVERSE_SUBTRACT = 0x800B; + public static final int GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B; + public static final int GL_FUNC_SUBTRACT = 0x800A; + public static final int GL_FUNC_SUBTRACT_EXT = 0x800A; + public static final int GL_GENERATE_MIPMAP_HINT_SGIS = 0x8192; + public static final int GL_GENERATE_MIPMAP_SGIS = 0x8191; + public static final int GL_GEQUAL = 0x0206; + public static final int GL_GLEXT_VERSION_EXT = 8; + public static final int GL_GLOBAL_ALPHA_FACTOR_SUN = 0x81DA; + public static final int GL_GLOBAL_ALPHA_SUN = 0x81D9; + public static final int GL_GREATER = 0x0204; + public static final int GL_GREEN = 0x1904; + public static final int GL_GREEN_BIAS = 0x0D19; + public static final int GL_GREEN_BITS = 0x0D53; + public static final int GL_GREEN_MAX_CLAMP_INGR = 0x8565; + public static final int GL_GREEN_MIN_CLAMP_INGR = 0x8561; + public static final int GL_GREEN_SCALE = 0x0D18; + public static final int GL_HALF_BIAS_NEGATE_NV = 0x853B; + public static final int GL_HALF_BIAS_NORMAL_NV = 0x853A; + public static final int GL_HINT_BIT = 0x00008000; + public static final int GL_HISTOGRAM = 0x8024; + public static final int GL_HISTOGRAM_ALPHA_SIZE = 0x802B; + public static final int GL_HISTOGRAM_ALPHA_SIZE_EXT = 0x802B; + public static final int GL_HISTOGRAM_BLUE_SIZE = 0x802A; + public static final int GL_HISTOGRAM_BLUE_SIZE_EXT = 0x802A; + public static final int GL_HISTOGRAM_EXT = 0x8024; + public static final int GL_HISTOGRAM_FORMAT = 0x8027; + public static final int GL_HISTOGRAM_FORMAT_EXT = 0x8027; + public static final int GL_HISTOGRAM_GREEN_SIZE = 0x8029; + public static final int GL_HISTOGRAM_GREEN_SIZE_EXT = 0x8029; + public static final int GL_HISTOGRAM_LUMINANCE_SIZE = 0x802C; + public static final int GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C; + public static final int GL_HISTOGRAM_RED_SIZE = 0x8028; + public static final int GL_HISTOGRAM_RED_SIZE_EXT = 0x8028; + public static final int GL_HISTOGRAM_SINK = 0x802D; + public static final int GL_HISTOGRAM_SINK_EXT = 0x802D; + public static final int GL_HISTOGRAM_WIDTH = 0x8026; + public static final int GL_HISTOGRAM_WIDTH_EXT = 0x8026; + public static final int GL_INCR = 0x1E02; + public static final int GL_INCR_WRAP_EXT = 0x8507; + public static final int GL_INDEX_ARRAY = 0x8077; + public static final int GL_INDEX_ARRAY_COUNT_EXT = 0x8087; + public static final int GL_INDEX_ARRAY_EXT = 0x8077; + public static final int GL_INDEX_ARRAY_POINTER = 0x8091; + public static final int GL_INDEX_ARRAY_POINTER_EXT = 0x8091; + public static final int GL_INDEX_ARRAY_STRIDE = 0x8086; + public static final int GL_INDEX_ARRAY_STRIDE_EXT = 0x8086; + public static final int GL_INDEX_ARRAY_TYPE = 0x8085; + public static final int GL_INDEX_ARRAY_TYPE_EXT = 0x8085; + public static final int GL_INDEX_BITS = 0x0D51; + public static final int GL_INDEX_CLEAR_VALUE = 0x0C20; + public static final int GL_INDEX_LOGIC_OP = 0x0BF1; + public static final int GL_INDEX_MODE = 0x0C30; + public static final int GL_INDEX_OFFSET = 0x0D13; + public static final int GL_INDEX_SHIFT = 0x0D12; + public static final int GL_INDEX_WRITEMASK = 0x0C21; + public static final int GL_INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180; + public static final int GL_INSTRUMENT_MEASUREMENTS_SGIX = 0x8181; + public static final int GL_INT = 0x1404; + public static final int GL_INTENSITY = 0x8049; + public static final int GL_INTENSITY12 = 0x804C; + public static final int GL_INTENSITY12_EXT = 0x804C; + public static final int GL_INTENSITY16 = 0x804D; + public static final int GL_INTENSITY16_EXT = 0x804D; + public static final int GL_INTENSITY4 = 0x804A; + public static final int GL_INTENSITY4_EXT = 0x804A; + public static final int GL_INTENSITY8 = 0x804B; + public static final int GL_INTENSITY8_EXT = 0x804B; + public static final int GL_INTENSITY_EXT = 0x8049; + public static final int GL_INTERLACE_READ_INGR = 0x8568; + public static final int GL_INTERLACE_SGIX = 0x8094; + public static final int GL_INTERPOLATE_EXT = 0x8575; + public static final int GL_INVALID_ENUM = 0x0500; + public static final int GL_INVALID_OPERATION = 0x0502; + public static final int GL_INVALID_VALUE = 0x0501; + public static final int GL_INVERT = 0x150A; + public static final int GL_INVERTED_SCREEN_W_REND = 0x8491; + public static final int GL_IR_INSTRUMENT1_SGIX = 0x817F; + public static final int GL_KEEP = 0x1E00; + public static final int GL_LEFT = 0x0406; + public static final int GL_LEQUAL = 0x0203; + public static final int GL_LESS = 0x0201; + public static final int GL_LIGHT0 = 0x4000; + public static final int GL_LIGHT1 = 0x4001; + public static final int GL_LIGHT2 = 0x4002; + public static final int GL_LIGHT3 = 0x4003; + public static final int GL_LIGHT4 = 0x4004; + public static final int GL_LIGHT5 = 0x4005; + public static final int GL_LIGHT6 = 0x4006; + public static final int GL_LIGHT7 = 0x4007; + public static final int GL_LIGHTING = 0x0B50; + public static final int GL_LIGHTING_BIT = 0x00000040; + public static final int GL_LIGHT_MODEL_AMBIENT = 0x0B53; + public static final int GL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8; + public static final int GL_LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8; + public static final int GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51; + public static final int GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0; + public static final int GL_LIGHT_MODEL_TWO_SIDE = 0x0B52; + public static final int GL_LINE = 0x1B01; + public static final int GL_LINEAR = 0x2601; + public static final int GL_LINEAR_ATTENUATION = 0x1208; + public static final int GL_LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170; + public static final int GL_LINEAR_DETAIL_ALPHA_SGIS = 0x8098; + public static final int GL_LINEAR_DETAIL_COLOR_SGIS = 0x8099; + public static final int GL_LINEAR_DETAIL_SGIS = 0x8097; + public static final int GL_LINEAR_MIPMAP_LINEAR = 0x2703; + public static final int GL_LINEAR_MIPMAP_NEAREST = 0x2701; + public static final int GL_LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE; + public static final int GL_LINEAR_SHARPEN_COLOR_SGIS = 0x80AF; + public static final int GL_LINEAR_SHARPEN_SGIS = 0x80AD; + public static final int GL_LINES = 0x0001; + public static final int GL_LINE_BIT = 0x00000004; + public static final int GL_LINE_LOOP = 0x0002; + public static final int GL_LINE_RESET_TOKEN = 0x0707; + public static final int GL_LINE_SMOOTH = 0x0B20; + public static final int GL_LINE_SMOOTH_HINT = 0x0C52; + public static final int GL_LINE_STIPPLE = 0x0B24; + public static final int GL_LINE_STIPPLE_PATTERN = 0x0B25; + public static final int GL_LINE_STIPPLE_REPEAT = 0x0B26; + public static final int GL_LINE_STRIP = 0x0003; + public static final int GL_LINE_TOKEN = 0x0702; + public static final int GL_LINE_WIDTH = 0x0B21; + public static final int GL_LINE_WIDTH_GRANULARITY = 0x0B23; + public static final int GL_LINE_WIDTH_RANGE = 0x0B22; + public static final int GL_LIST_BASE = 0x0B32; + public static final int GL_LIST_BIT = 0x00020000; + public static final int GL_LIST_INDEX = 0x0B33; + public static final int GL_LIST_MODE = 0x0B30; + public static final int GL_LIST_PRIORITY_SGIX = 0x8182; + public static final int GL_LOAD = 0x0101; + public static final int GL_LOGIC_OP = 0x0BF1; + public static final int GL_LOGIC_OP_MODE = 0x0BF0; + public static final int GL_LUMINANCE = 0x1909; + public static final int GL_LUMINANCE12 = 0x8041; + public static final int GL_LUMINANCE12_ALPHA12 = 0x8047; + public static final int GL_LUMINANCE12_ALPHA12_EXT = 0x8047; + public static final int GL_LUMINANCE12_ALPHA4 = 0x8046; + public static final int GL_LUMINANCE12_ALPHA4_EXT = 0x8046; + public static final int GL_LUMINANCE12_EXT = 0x8041; + public static final int GL_LUMINANCE16 = 0x8042; + public static final int GL_LUMINANCE16_ALPHA16 = 0x8048; + public static final int GL_LUMINANCE16_ALPHA16_EXT = 0x8048; + public static final int GL_LUMINANCE16_EXT = 0x8042; + public static final int GL_LUMINANCE4 = 0x803F; + public static final int GL_LUMINANCE4_ALPHA4 = 0x8043; + public static final int GL_LUMINANCE4_ALPHA4_EXT = 0x8043; + public static final int GL_LUMINANCE4_EXT = 0x803F; + public static final int GL_LUMINANCE6_ALPHA2 = 0x8044; + public static final int GL_LUMINANCE6_ALPHA2_EXT = 0x8044; + public static final int GL_LUMINANCE8 = 0x8040; + public static final int GL_LUMINANCE8_ALPHA8 = 0x8045; + public static final int GL_LUMINANCE8_ALPHA8_EXT = 0x8045; + public static final int GL_LUMINANCE8_EXT = 0x8040; + public static final int GL_LUMINANCE_ALPHA = 0x190A; + public static final int GL_MAP1_BINORMAL_EXT = 0x8446; + public static final int GL_MAP1_COLOR_4 = 0x0D90; + public static final int GL_MAP1_GRID_DOMAIN = 0x0DD0; + public static final int GL_MAP1_GRID_SEGMENTS = 0x0DD1; + public static final int GL_MAP1_INDEX = 0x0D91; + public static final int GL_MAP1_NORMAL = 0x0D92; + public static final int GL_MAP1_TANGENT_EXT = 0x8444; + public static final int GL_MAP1_TEXTURE_COORD_1 = 0x0D93; + public static final int GL_MAP1_TEXTURE_COORD_2 = 0x0D94; + public static final int GL_MAP1_TEXTURE_COORD_3 = 0x0D95; + public static final int GL_MAP1_TEXTURE_COORD_4 = 0x0D96; + public static final int GL_MAP1_VERTEX_3 = 0x0D97; + public static final int GL_MAP1_VERTEX_4 = 0x0D98; + public static final int GL_MAP2_BINORMAL_EXT = 0x8447; + public static final int GL_MAP2_COLOR_4 = 0x0DB0; + public static final int GL_MAP2_GRID_DOMAIN = 0x0DD2; + public static final int GL_MAP2_GRID_SEGMENTS = 0x0DD3; + public static final int GL_MAP2_INDEX = 0x0DB1; + public static final int GL_MAP2_NORMAL = 0x0DB2; + public static final int GL_MAP2_TANGENT_EXT = 0x8445; + public static final int GL_MAP2_TEXTURE_COORD_1 = 0x0DB3; + public static final int GL_MAP2_TEXTURE_COORD_2 = 0x0DB4; + public static final int GL_MAP2_TEXTURE_COORD_3 = 0x0DB5; + public static final int GL_MAP2_TEXTURE_COORD_4 = 0x0DB6; + public static final int GL_MAP2_VERTEX_3 = 0x0DB7; + public static final int GL_MAP2_VERTEX_4 = 0x0DB8; + public static final int GL_MAP_COLOR = 0x0D10; + public static final int GL_MAP_STENCIL = 0x0D11; + public static final int GL_MATRIX_MODE = 0x0BA0; + public static final int GL_MAX = 0x8008; + public static final int GL_MAX_3D_TEXTURE_SIZE = 0x8073; + public static final int GL_MAX_3D_TEXTURE_SIZE_EXT = 0x8073; + public static final int GL_MAX_4D_TEXTURE_SIZE_SGIS = 0x8138; + public static final int GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35; + public static final int GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B; + public static final int GL_MAX_CLIPMAP_DEPTH_SGIX = 0x8177; + public static final int GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178; + public static final int GL_MAX_CLIP_PLANES = 0x0D32; + public static final int GL_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3; + public static final int GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3; + public static final int GL_MAX_CONVOLUTION_HEIGHT = 0x801B; + public static final int GL_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B; + public static final int GL_MAX_CONVOLUTION_WIDTH = 0x801A; + public static final int GL_MAX_CONVOLUTION_WIDTH_EXT = 0x801A; + public static final int GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C; + public static final int GL_MAX_ELEMENTS_INDICES = 0x80E9; + public static final int GL_MAX_ELEMENTS_INDICES_EXT = 0x80E9; + public static final int GL_MAX_ELEMENTS_VERTICES = 0x80E8; + public static final int GL_MAX_ELEMENTS_VERTICES_EXT = 0x80E8; + public static final int GL_MAX_EVAL_ORDER = 0x0D30; + public static final int GL_MAX_EXT = 0x8008; + public static final int GL_MAX_FOG_FUNC_POINTS_SGIS = 0x812C; + public static final int GL_MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D; + public static final int GL_MAX_GENERAL_COMBINERS_NV = 0x854D; + public static final int GL_MAX_LIGHTS = 0x0D31; + public static final int GL_MAX_LIST_NESTING = 0x0B31; + public static final int GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36; + public static final int GL_MAX_NAME_STACK_DEPTH = 0x0D37; + public static final int GL_MAX_PIXEL_MAP_TABLE = 0x0D34; + public static final int GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337; + public static final int GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38; + public static final int GL_MAX_SHININESS_NV = 0x8507; + public static final int GL_MAX_SPOT_EXPONENT_NV = 0x8508; + public static final int GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF; + public static final int GL_MAX_TEXTURE_SIZE = 0x0D33; + public static final int GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39; + public static final int GL_MAX_TEXTURE_UNITS_ARB = 0x84E2; + public static final int GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520; + public static final int GL_MAX_VIEWPORT_DIMS = 0x0D3A; + public static final int GL_MIN = 0x8007; + public static final int GL_MINMAX = 0x802E; + public static final int GL_MINMAX_FORMAT = 0x802F; + public static final int GL_MINMAX_SINK = 0x8030; + public static final int GL_MIN_EXT = 0x8007; + public static final int GL_MIRRORED_REPEAT_IBM = 0x8370; + public static final int GL_MODELVIEW = 0x1700; + public static final int GL_MODELVIEW0_EXT = 0x1700; + public static final int GL_MODELVIEW0_STACK_DEPTH_EXT = 0x0BA3; + public static final int GL_MODELVIEW1_EXT = 0x850A; + public static final int GL_MODELVIEW1_STACK_DEPTH_EXT = 0x8502; + public static final int GL_MODELVIEW_MATRIX = 0x0BA6; + public static final int GL_MODELVIEW_STACK_DEPTH = 0x0BA3; + public static final int GL_MODULATE = 0x2100; + public static final int GL_MULT = 0x0103; + public static final int GL_MULTISAMPLE_ARBfunda = 0x809D; + public static final int GL_MULTISAMPLE_BIT_ARB = 0x20000000; + public static final int GL_MULTISAMPLE_BIT_EXT = 0x20000000; + public static final int GL_MULTISAMPLE_SGIS = 0x809D; + public static final int GL_N3F_V3F = 0x2A25; + public static final int GL_NAME_STACK_DEPTH = 0x0D70; + public static final int GL_NAND = 0x150E; + public static final int GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 107011; + public static final int GL_NATIVE_GRAPHICS_END_HINT_PGI = 107012; + public static final int GL_NATIVE_GRAPHICS_HANDLE_PGI = 107010; + public static final int GL_NEAREST = 0x2600; + public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702; + public static final int GL_NEAREST_MIPMAP_NEAREST = 0x2700; + public static final int GL_NEVER = 0x0200; + public static final int GL_NICEST = 0x1102; + public static final int GL_NONE = 0x0; + public static final int GL_NOOP = 0x1505; + public static final int GL_NOR = 0x1508; + public static final int GL_NORMALIZE = 0x0BA1; + public static final int GL_NORMAL_ARRAY = 0x8075; + public static final int GL_NORMAL_ARRAY_COUNT_EXT = 0x8080; + public static final int GL_NORMAL_ARRAY_EXT = 0x8075; + public static final int GL_NORMAL_ARRAY_POINTER = 0x808F; + public static final int GL_NORMAL_ARRAY_POINTER_EXT = 0x808F; + public static final int GL_NORMAL_ARRAY_STRIDE = 0x807F; + public static final int GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F; + public static final int GL_NORMAL_ARRAY_TYPE = 0x807E; + public static final int GL_NORMAL_ARRAY_TYPE_EXT = 0x807E; + public static final int GL_NORMAL_MAP_EXT = 0x8511; + public static final int GL_NORMAL_MAP_NV = 0x8511; + public static final int GL_NOTEQUAL = 0x0205; + public static final int GL_NO_ERROR = 0x0; + public static final int GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2; + public static final int GL_NUM_GENERAL_COMBINERS_NV = 0x854E; + public static final int GL_OBJECT_LINEAR = 0x2401; + public static final int GL_OBJECT_PLANE = 0x2501; + public static final int GL_OCCLUSION_TEST_HP = 0x8165; + public static final int GL_OCCLUSION_TEST_RESULT_HP = 0x8166; + public static final int GL_ONE = 0x1; + public static final int GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004; + public static final int GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004; + public static final int GL_ONE_MINUS_CONSTANT_COLOR = 0x8002; + public static final int GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002; + public static final int GL_ONE_MINUS_DST_ALPHA = 0x0305; + public static final int GL_ONE_MINUS_DST_COLOR = 0x0307; + public static final int GL_ONE_MINUS_SRC_ALPHA = 0x0303; + public static final int GL_ONE_MINUS_SRC_COLOR = 0x0301; + public static final int GL_OPERAND0_ALPHA_EXT = 0x8598; + public static final int GL_OPERAND0_RGB_EXT = 0x8590; + public static final int GL_OPERAND1_ALPHA_EXT = 0x8599; + public static final int GL_OPERAND1_RGB_EXT = 0x8591; + public static final int GL_OPERAND2_ALPHA_EXT = 0x859A; + public static final int GL_OPERAND2_RGB_EXT = 0x8592; + public static final int GL_OPERAND3_ALPHA_NV = 0x859B; + public static final int GL_OPERAND3_RGB_NV = 0x8593; + public static final int GL_OR = 0x1507; + public static final int GL_ORDER = 0x0A01; + public static final int GL_OR_INVERTED = 0x150D; + public static final int GL_OR_REVERSE = 0x150B; + public static final int GL_OUT_OF_MEMORY = 0x0505; + public static final int GL_PACK_ALIGNMENT = 0x0D05; + public static final int GL_PACK_CMYK_HINT_EXT = 0x800E; + public static final int GL_PACK_IMAGE_DEPTH_SGIS = 0x8131; + public static final int GL_PACK_IMAGE_HEIGHT = 0x806C; + public static final int GL_PACK_IMAGE_HEIGHT_EXT = 0x806C; + public static final int GL_PACK_LSB_FIRST = 0x0D01; + public static final int GL_PACK_ROW_LENGTH = 0x0D02; + public static final int GL_PACK_SKIP_IMAGES = 0x806B; + public static final int GL_PACK_SKIP_IMAGES_EXT = 0x806B; + public static final int GL_PACK_SKIP_PIXELS = 0x0D04; + public static final int GL_PACK_SKIP_ROWS = 0x0D03; + public static final int GL_PACK_SKIP_VOLUMES_SGIS = 0x8130; + public static final int GL_PACK_SWAP_BYTES = 0x0D00; + public static final int GL_PASS_THROUGH_TOKEN = 0x0700; + public static final int GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50; + public static final int GL_PERTURB_EXT = 0x85AE; + public static final int GL_PHONG_HINT_WIN = 0x80EB; + public static final int GL_PHONG_WIN = 0x80EA; + public static final int GL_PIXEL_CUBIC_WEIGHT_EXT = 0x8333; + public static final int GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x1002; + public static final int GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x1001; + public static final int GL_PIXEL_GROUP_COLOR_SGIS = 0x1003; + public static final int GL_PIXEL_MAG_FILTER_EXT = 0x8331; + public static final int GL_PIXEL_MAP_A_TO_A = 0x0C79; + public static final int GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9; + public static final int GL_PIXEL_MAP_B_TO_B = 0x0C78; + public static final int GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8; + public static final int GL_PIXEL_MAP_G_TO_G = 0x0C77; + public static final int GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7; + public static final int GL_PIXEL_MAP_I_TO_A = 0x0C75; + public static final int GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5; + public static final int GL_PIXEL_MAP_I_TO_B = 0x0C74; + public static final int GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4; + public static final int GL_PIXEL_MAP_I_TO_G = 0x0C73; + public static final int GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3; + public static final int GL_PIXEL_MAP_I_TO_I = 0x0C70; + public static final int GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0; + public static final int GL_PIXEL_MAP_I_TO_R = 0x0C72; + public static final int GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2; + public static final int GL_PIXEL_MAP_R_TO_R = 0x0C76; + public static final int GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6; + public static final int GL_PIXEL_MAP_S_TO_S = 0x0C71; + public static final int GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1; + public static final int GL_PIXEL_MIN_FILTER_EXT = 0x8332; + public static final int GL_PIXEL_MODE_BIT = 0x00000020; + public static final int GL_PIXEL_TEXTURE_SGIS = 0x1000; + public static final int GL_PIXEL_TEX_GEN_MODE_SGIX = 0x832B; + public static final int GL_PIXEL_TEX_GEN_SGIX = 0x8139; + public static final int GL_PIXEL_TRANSFORM_2D_EXT = 0x8330; + public static final int GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338; + public static final int GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336; + public static final int GL_POINT = 0x1B00; + public static final int GL_POINTS = 0x0000; + public static final int GL_POINT_BIT = 0x00000002; + public static final int GL_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128; + public static final int GL_POINT_SIZE = 0x0B11; + public static final int GL_POINT_SIZE_GRANULARITY = 0x0B13; + public static final int GL_POINT_SIZE_MAX_EXT = 0x8127; + public static final int GL_POINT_SIZE_MIN_EXT = 0x8126; + public static final int GL_POINT_SIZE_RANGE = 0x0B12; + public static final int GL_POINT_SMOOTH = 0x0B10; + public static final int GL_POINT_SMOOTH_HINT = 0x0C51; + public static final int GL_POINT_TOKEN = 0x0701; + public static final int GL_POLYGON = 0x0009; + public static final int GL_POLYGON_BIT = 0x00000008; + public static final int GL_POLYGON_MODE = 0x0B40; + public static final int GL_POLYGON_OFFSET_BIAS_EXT = 0x8039; + public static final int GL_POLYGON_OFFSET_EXT = 0x8037; + public static final int GL_POLYGON_OFFSET_FACTOR = 0x8038; + public static final int GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038; + public static final int GL_POLYGON_OFFSET_FILL = 0x8037; + public static final int GL_POLYGON_OFFSET_LINE = 0x2A02; + public static final int GL_POLYGON_OFFSET_POINT = 0x2A01; + public static final int GL_POLYGON_OFFSET_UNITS = 0x2A00; + public static final int GL_POLYGON_SMOOTH = 0x0B41; + public static final int GL_POLYGON_SMOOTH_HINT = 0x0C53; + public static final int GL_POLYGON_STIPPLE = 0x0B42; + public static final int GL_POLYGON_STIPPLE_BIT = 0x00000010; + public static final int GL_POLYGON_TOKEN = 0x0703; + public static final int GL_POSITION = 0x1203; + public static final int GL_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB; + public static final int GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB; + public static final int GL_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7; + public static final int GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7; + public static final int GL_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA; + public static final int GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA; + public static final int GL_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6; + public static final int GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6; + public static final int GL_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2; + public static final int GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2; + public static final int GL_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9; + public static final int GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9; + public static final int GL_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5; + public static final int GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5; + public static final int GL_POST_COLOR_MATRIX_RED_BIAS = 0x80B8; + public static final int GL_POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8; + public static final int GL_POST_COLOR_MATRIX_RED_SCALE = 0x80B4; + public static final int GL_POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4; + public static final int GL_POST_CONVOLUTION_ALPHA_BIAS = 0x8023; + public static final int GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023; + public static final int GL_POST_CONVOLUTION_ALPHA_SCALE = 0x801F; + public static final int GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F; + public static final int GL_POST_CONVOLUTION_BLUE_BIAS = 0x8022; + public static final int GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022; + public static final int GL_POST_CONVOLUTION_BLUE_SCALE = 0x801E; + public static final int GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E; + public static final int GL_POST_CONVOLUTION_COLOR_TABLE = 0x80D1; + public static final int GL_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1; + public static final int GL_POST_CONVOLUTION_GREEN_BIAS = 0x8021; + public static final int GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021; + public static final int GL_POST_CONVOLUTION_GREEN_SCALE = 0x801D; + public static final int GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D; + public static final int GL_POST_CONVOLUTION_RED_BIAS = 0x8020; + public static final int GL_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020; + public static final int GL_POST_CONVOLUTION_RED_SCALE = 0x801C; + public static final int GL_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C; + public static final int GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B; + public static final int GL_POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179; + public static final int GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C; + public static final int GL_POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A; + public static final int GL_PREFER_DOUBLEBUFFER_HINT_PGI = 107000; + public static final int GL_PREVIOUS_EXT = 0x8578; + public static final int GL_PRIMARY_COLOR_EXT = 0x8577; + public static final int GL_PRIMARY_COLOR_NV = 0x852C; + public static final int GL_PROJECTION = 0x1701; + public static final int GL_PROJECTION_MATRIX = 0x0BA7; + public static final int GL_PROJECTION_STACK_DEPTH = 0x0BA4; + public static final int GL_PROXY_COLOR_TABLE = 0x80D3; + public static final int GL_PROXY_COLOR_TABLE_SGI = 0x80D3; + public static final int GL_PROXY_HISTOGRAM = 0x8025; + public static final int GL_PROXY_HISTOGRAM_EXT = 0x8025; + public static final int GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5; + public static final int GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5; + public static final int GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4; + public static final int GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4; + public static final int GL_PROXY_TEXTURE_1D = 0x8063; + public static final int GL_PROXY_TEXTURE_1D_EXT = 0x8063; + public static final int GL_PROXY_TEXTURE_2D = 0x8064; + public static final int GL_PROXY_TEXTURE_2D_EXT = 0x8064; + public static final int GL_PROXY_TEXTURE_3D = 0x8070; + public static final int GL_PROXY_TEXTURE_3D_EXT = 0x8070; + public static final int GL_PROXY_TEXTURE_4D_SGIS = 0x8135; + public static final int GL_PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD; + public static final int GL_PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B; + public static final int GL_Q = 0x2003; + public static final int GL_QUADRATIC_ATTENUATION = 0x1209; + public static final int GL_QUADS = 0x0007; + public static final int GL_QUAD_ALPHA4_SGIS = 0x811E; + public static final int GL_QUAD_ALPHA8_SGIS = 0x811F; + public static final int GL_QUAD_INTENSITY4_SGIS = 0x8122; + public static final int GL_QUAD_INTENSITY8_SGIS = 0x8123; + public static final int GL_QUAD_LUMINANCE4_SGIS0 = 0x8120; + public static final int GL_QUAD_LUMINANCE8_SGIS = 0x8121; + public static final int GL_QUAD_STRIP = 0x0008; + public static final int GL_QUAD_TEXTURE_SELECT_SGIS = 0x8125; + public static final int GL_R = 0x2002; + public static final int GL_R1UI_C3F_V3F_SUN = 0x85C6; + public static final int GL_R1UI_C4F_N3F_V3F_SUN = 0x85C8; + public static final int GL_R1UI_C4UB_V3F_SUN = 0x85C5; + public static final int GL_R1UI_N3F_V3F_SUN = 0x85C7; + public static final int GL_R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB; + public static final int GL_R1UI_T2F_N3F_V3F_SUN = 0x85CA; + public static final int GL_R1UI_T2F_V3F_SUN = 0x85C9; + public static final int GL_R1UI_V3F_SUN = 0x85C4; + public static final int GL_R3_G3_B2 = 0x2A10; + public static final int GL_READ_BUFFER = 0x0C02; + public static final int GL_RECLAIM_MEMORY_HINT_PGI = 107006; + public static final int GL_RED = 0x1903; + public static final int GL_REDUCE = 0x8016; + public static final int GL_REDUCE_EXT = 0x8016; + public static final int GL_RED_BIAS = 0x0D15; + public static final int GL_RED_BITS = 0x0D52; + public static final int GL_RED_MAX_CLAMP_INGR = 0x8564; + public static final int GL_RED_MIN_CLAMP_INGR = 0x8560; + public static final int GL_RED_SCALE = 0x0D14; + public static final int GL_REFERENCE_PLANE_EQUATION_SGIX = 0x817E; + public static final int GL_REFERENCE_PLANE_SGIX = 0x817D; + public static final int GL_REFLECTION_MAP_EXT = 0x8512; + public static final int GL_REFLECTION_MAP_NV = 0x8512; + public static final int GL_REGISTER_COMBINERS_NV = 0x8522; + public static final int GL_RENDER = 0x1C00; + public static final int GL_RENDERER = 0x1F01; + public static final int GL_RENDER_MODE = 0x0C40; + public static final int GL_REPEAT = 0x2901; + public static final int GL_REPLACE = 0x1E01; + public static final int GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3; + public static final int GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2; + public static final int GL_REPLACEMENT_CODE_ARRAY_SUN = 0x85C0; + public static final int GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1; + public static final int GL_REPLACEMENT_CODE_SUN = 0x81D8; + public static final int GL_REPLACE_EXT = 0x8062; + public static final int GL_REPLACE_MIDDLE_SUN = 0x02; + public static final int GL_REPLACE_OLDEST_SUN = 0x03; + public static final int GL_REPLICATE_BORDER = 0x8153; + public static final int GL_RESCALE_NORMAL = 0x803A; + public static final int GL_RESCALE_NORMAL_EXT = 0x803A; + public static final int GL_RESTART_SUN = 0x01; + public static final int GL_RETURN = 0x0102; + public static final int GL_RGB = 0x1907; + public static final int GL_RGB10 = 0x8052; + public static final int GL_RGB10_A2 = 0x8059; + public static final int GL_RGB10_A2_EXT = 0x8059; + public static final int GL_RGB10_EXT = 0x8052; + public static final int GL_RGB12 = 0x8053; + public static final int GL_RGB12_EXT = 0x8053; + public static final int GL_RGB16 = 0x8054; + public static final int GL_RGB16_EXT = 0x8054; + public static final int GL_RGB2_EXT = 0x804E; + public static final int GL_RGB4 = 0x804F; + public static final int GL_RGB4_EXT = 0x804F; + public static final int GL_RGB5 = 0x8050; + public static final int GL_RGB5_A1 = 0x8057; + public static final int GL_RGB5_A1_EXT = 0x8057; + public static final int GL_RGB5_EXT = 0x8050; + public static final int GL_RGB8 = 0x8051; + public static final int GL_RGB8_EXT = 0x8051; + public static final int GL_RGBA = 0x1908; + public static final int GL_RGBA12 = 0x805A; + public static final int GL_RGBA12_EXT = 0x805A; + public static final int GL_RGBA16 = 0x805B; + public static final int GL_RGBA16_EXT = 0x805B; + public static final int GL_RGBA2 = 0x8055; + public static final int GL_RGBA2_EXT = 0x8055; + public static final int GL_RGBA4 = 0x8056; + public static final int GL_RGBA4_EXT = 0x8056; + public static final int GL_RGBA8 = 0x8058; + public static final int GL_RGBA8_EXT = 0x8058; + public static final int GL_RGBA_MODE = 0x0C31; + public static final int GL_RGB_SCALE_EXT = 0x8573; + public static final int GL_RIGHT = 0x0407; + public static final int GL_S = 0x2000; + public static final int GL_SAMPLES_ARB = 0x80A9; + public static final int GL_SAMPLES_SGIS = 0x80A9; + public static final int GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E; + public static final int GL_SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E; + public static final int GL_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F; + public static final int GL_SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F; + public static final int GL_SAMPLE_BUFFERS_ARB = 0x80A8; + public static final int GL_SAMPLE_BUFFERS_SGIS = 0x80A8; + public static final int GL_SAMPLE_COVERAGE_ARB = 0x80A0; + public static final int GL_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB; + public static final int GL_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA; + public static final int GL_SAMPLE_MASK_INVERT_SGIS = 0x80AB; + public static final int GL_SAMPLE_MASK_SGIS = 0x80A0; + public static final int GL_SAMPLE_MASK_VALUE_SGIS = 0x80AA; + public static final int GL_SAMPLE_MAX_PASSES_ARB = 0x84E7; + public static final int GL_SAMPLE_PASS_ARB = 0x84E8; + public static final int GL_SAMPLE_PATTERN_SGIS = 0x80AC; + public static final int GL_SCALE_BY_FOUR_NV = 0x853F; + public static final int GL_SCALE_BY_ONE_HALF_NV = 0x8540; + public static final int GL_SCALE_BY_TWO_NV = 0x853E; + public static final int GL_SCISSOR_BIT = 0x00080000; + public static final int GL_SCISSOR_BOX = 0x0C10; + public static final int GL_SCISSOR_TEST = 0x0C11; + public static final int GL_SCREEN_COORDINATES_REND = 0x8490; + public static final int GL_SECONDARY_COLOR_ARRAY_EXT = 0x845E; + public static final int GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D; + public static final int GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A; + public static final int GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C; + public static final int GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B; + public static final int GL_SECONDARY_COLOR_NV = 0x852D; + public static final int GL_SELECT = 0x1C02; + public static final int GL_SELECTION_BUFFER_POINTER = 0x0DF3; + public static final int GL_SELECTION_BUFFER_SIZE = 0x0DF4; + public static final int GL_SEPARABLE_2D = 0x8012; + public static final int GL_SEPARABLE_2D_EXT = 0x8012; + public static final int GL_SEPARATE_SPECULAR_COLOR = 0x81FA; + public static final int GL_SEPARATE_SPECULAR_COLOR_EXT = 0x81FA; + public static final int GL_SET = 0x150F; + public static final int GL_SHADE_MODEL = 0x0B54; + public static final int GL_SHADOW_ATTENUATION_EXT = 0x834E; + public static final int GL_SHARED_TEXTURE_PALETTE_EXT = 0x81FB; + public static final int GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0; + public static final int GL_SHININESS = 0x1601; + public static final int GL_SHORT = 0x1402; + public static final int GL_SIGNED_IDENTITY_NV = 0x853C; + public static final int GL_SIGNED_NEGATE_NV = 0x853D; + public static final int GL_SINGLE_COLOR = 0x81F9; + public static final int GL_SINGLE_COLOR_EXT = 0x81F9; + public static final int GL_SMOOTH = 0x1D01; + public static final int GL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; + public static final int GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22; + public static final int GL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; + public static final int GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12; + public static final int GL_SOURCE0_ALPHA_EXT = 0x8588; + public static final int GL_SOURCE0_RGB_EXT = 0x8580; + public static final int GL_SOURCE1_ALPHA_EXT = 0x8589; + public static final int GL_SOURCE1_RGB_EXT = 0x8581; + public static final int GL_SOURCE2_ALPHA_EXT = 0x858A; + public static final int GL_SOURCE2_RGB_EXT = 0x8582; + public static final int GL_SOURCE3_ALPHA_NV = 0x858B; + public static final int GL_SOURCE3_RGB_NV = 0x8583; + public static final int GL_SPARE0_NV = 0x852E; + public static final int GL_SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532; + public static final int GL_SPARE1_NV = 0x852F; + public static final int GL_SPECULAR = 0x1202; + public static final int GL_SPHERE_MAP = 0x2402; + public static final int GL_SPOT_CUTOFF = 0x1206; + public static final int GL_SPOT_DIRECTION = 0x1204; + public static final int GL_SPOT_EXPONENT = 0x1205; + public static final int GL_SPRITE_AXIAL_SGIX = 0x814C; + public static final int GL_SPRITE_AXIS_SGIX = 0x814A; + public static final int GL_SPRITE_EYE_ALIGNED_SGIX = 0x814E; + public static final int GL_SPRITE_MODE_SGIX = 0x8149; + public static final int GL_SPRITE_OBJECT_ALIGNED_SGIX = 0x814D; + public static final int GL_SPRITE_SGIX = 0x8148; + public static final int GL_SPRITE_TRANSLATION_SGIX = 0x814B; + public static final int GL_SRC_ALPHA = 0x0302; + public static final int GL_SRC_ALPHA_SATURATE = 0x0308; + public static final int GL_SRC_COLOR = 0x0300; + public static final int GL_STACK_OVERFLOW = 0x0503; + public static final int GL_STACK_UNDERFLOW = 0x0504; + public static final int GL_STATIC_VERTEX_ARRAY_IBM = 0x19295; + public static final int GL_STENCIL = 0x1802; + public static final int GL_STENCIL_BITS = 0x0D57; + public static final int GL_STENCIL_BUFFER_BIT = 0x00000400; + public static final int GL_STENCIL_CLEAR_VALUE = 0x0B91; + public static final int GL_STENCIL_FAIL = 0x0B94; + public static final int GL_STENCIL_FUNC = 0x0B92; + public static final int GL_STENCIL_INDEX = 0x1901; + public static final int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; + public static final int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; + public static final int GL_STENCIL_REF = 0x0B97; + public static final int GL_STENCIL_TEST = 0x0B90; + public static final int GL_STENCIL_VALUE_MASK = 0x0B93; + public static final int GL_STENCIL_WRITEMASK = 0x0B98; + public static final int GL_STEREO = 0x0C33; + public static final int GL_STRICT_DEPTHFUNC_HINT_PGI = 107030; + public static final int GL_STRICT_LIGHTING_HINT_PGI = 107031; + public static final int GL_STRICT_SCISSOR_HINT_PGI = 107032; + public static final int GL_SUBPIXEL_BITS = 0x0D50; + public static final int GL_T = 0x2001; + public static final int GL_T2F_C3F_V3F = 0x2A2A; + public static final int GL_T2F_C4F_N3F_V3F = 0x2A2C; + public static final int GL_T2F_C4UB_V3F = 0x2A29; + public static final int GL_T2F_N3F_V3F = 0x2A2B; + public static final int GL_T2F_V3F = 0x2A27; + public static final int GL_T4F_C4F_N3F_V4F = 0x2A2D; + public static final int GL_T4F_V4F = 0x2A28; + public static final int GL_TABLE_TOO_LARGE = 0x8031; + public static final int GL_TABLE_TOO_LARGE_EXT = 0x8031; + public static final int GL_TANGENT_ARRAY_EXT = 0x8439; + public static final int GL_TANGENT_ARRAY_POINTER_EXT = 0x8442; + public static final int GL_TANGENT_ARRAY_STRIDE_EXT = 0x843F; + public static final int GL_TANGENT_ARRAY_TYPE_EXT = 0x843E; + public static final int GL_TEXTURE = 0x1702; + public static final int GL_TEXTURE0_ARB = 0x84C0; + public static final int GL_TEXTURE10_ARB = 0x84CA; + public static final int GL_TEXTURE11_ARB = 0x84CB; + public static final int GL_TEXTURE12_ARB = 0x84CC; + public static final int GL_TEXTURE13_ARB = 0x84CD; + public static final int GL_TEXTURE14_ARB = 0x84CE; + public static final int GL_TEXTURE15_ARB = 0x84CF; + public static final int GL_TEXTURE16_ARB = 0x84D0; + public static final int GL_TEXTURE17_ARB = 0x84D1; + public static final int GL_TEXTURE18_ARB = 0x84D2; + public static final int GL_TEXTURE19_ARB = 0x84D3; + public static final int GL_TEXTURE1_ARB = 0x84C1; + public static final int GL_TEXTURE20_ARB = 0x84D4; + public static final int GL_TEXTURE21_ARB = 0x84D5; + public static final int GL_TEXTURE22_ARB = 0x84D6; + public static final int GL_TEXTURE23_ARB = 0x84D7; + public static final int GL_TEXTURE24_ARB = 0x84D8; + public static final int GL_TEXTURE25_ARB = 0x84D9; + public static final int GL_TEXTURE26_ARB = 0x84DA; + public static final int GL_TEXTURE27_ARB = 0x84DB; + public static final int GL_TEXTURE28_ARB = 0x84DC; + public static final int GL_TEXTURE29_ARB = 0x84DD; + public static final int GL_TEXTURE2_ARB = 0x84C2; + public static final int GL_TEXTURE30_ARB = 0x84DE; + public static final int GL_TEXTURE31_ARB = 0x84DF; + public static final int GL_TEXTURE3_ARB = 0x84C3; + public static final int GL_TEXTURE4_ARB = 0x84C4; + public static final int GL_TEXTURE5_ARB = 0x84C5; + public static final int GL_TEXTURE6_ARB = 0x84C6; + public static final int GL_TEXTURE7_ARB = 0x84C7; + public static final int GL_TEXTURE8_ARB = 0x84C8; + public static final int GL_TEXTURE9_ARB = 0x84C9; + public static final int GL_TEXTURE_1D = 0x0DE0; + public static final int GL_TEXTURE_1D_BINDING_EXT = 0x8068; + public static final int GL_TEXTURE_2D = 0x0DE1; + public static final int GL_TEXTURE_2D_BINDING_EXT = 0x8069; + public static final int GL_TEXTURE_3D = 0x806F; + public static final int GL_TEXTURE_3D_BINDING_EXT = 0x806A; + public static final int GL_TEXTURE_3D_EXT = 0x806F; + public static final int GL_TEXTURE_4DSIZE_SGIS = 0x8136; + public static final int GL_TEXTURE_4D_BINDING_SGIS = 0x814F; + public static final int GL_TEXTURE_4D_SGIS = 0x8134; + public static final int GL_TEXTURE_ALPHA_SIZE = 0x805F; + public static final int GL_TEXTURE_ALPHA_SIZE_EXT = 0x805F; + public static final int GL_TEXTURE_APPLICATION_MODE_EXT = 0x834F; + public static final int GL_TEXTURE_BASE_LEVEL = 0x813C; + public static final int GL_TEXTURE_BASE_LEVEL_SGIS = 0x813C; + public static final int GL_TEXTURE_BINDING_1D = 0x8068; + public static final int GL_TEXTURE_BINDING_2D = 0x8069; + public static final int GL_TEXTURE_BINDING_3D = 0x806A; + public static final int GL_TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514; + public static final int GL_TEXTURE_BIT = 0x00040000; + public static final int GL_TEXTURE_BLUE_SIZE = 0x805E; + public static final int GL_TEXTURE_BLUE_SIZE_EXT = 0x805E; + public static final int GL_TEXTURE_BORDER = 0x1005; + public static final int GL_TEXTURE_BORDER_COLOR = 0x1004; + public static final int GL_TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171; + public static final int GL_TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176; + public static final int GL_TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172; + public static final int GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175; + public static final int GL_TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173; + public static final int GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174; + public static final int GL_TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B; + public static final int GL_TEXTURE_COMPARE_SGIX = 0x819A; + public static final int GL_TEXTURE_COMPONENTS = 0x1003; + public static final int GL_TEXTURE_COMPRESSED_ARB = 0x86A1; + public static final int GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0; + public static final int GL_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF; + public static final int GL_TEXTURE_CONSTANT_DATA_SUNX = 0x81D6; + public static final int GL_TEXTURE_COORD_ARRAY = 0x8078; + public static final int GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B; + public static final int GL_TEXTURE_COORD_ARRAY_EXT = 0x8078; + public static final int GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092; + public static final int GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092; + public static final int GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088; + public static final int GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088; + public static final int GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A; + public static final int GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A; + public static final int GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089; + public static final int GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089; + public static final int GL_TEXTURE_CUBE_MAP_EXT = 0x8513; + public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516; + public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518; + public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A; + public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515; + public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517; + public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519; + public static final int GL_TEXTURE_DEPTH = 0x8071; + public static final int GL_TEXTURE_DEPTH_EXT = 0x8071; + public static final int GL_TEXTURE_ENV = 0x2300; + public static final int GL_TEXTURE_ENV_BIAS_SGIX = 0x80BE; + public static final int GL_TEXTURE_ENV_COLOR = 0x2201; + public static final int GL_TEXTURE_ENV_MODE = 0x2200; + public static final int GL_TEXTURE_FILTER4_SIZE_SGIS = 0x8147; + public static final int GL_TEXTURE_FILTER_CONTROL_EXT = 0x8500; + public static final int GL_TEXTURE_GEN_MODE = 0x2500; + public static final int GL_TEXTURE_GEN_Q = 0x0C63; + public static final int GL_TEXTURE_GEN_R = 0x0C62; + public static final int GL_TEXTURE_GEN_S = 0x0C60; + public static final int GL_TEXTURE_GEN_T = 0x0C61; + public static final int GL_TEXTURE_GEQUAL_R_SGIX = 0x819D; + public static final int GL_TEXTURE_GREEN_SIZE = 0x805D; + public static final int GL_TEXTURE_GREEN_SIZE_EXT = 0x805D; + public static final int GL_TEXTURE_HEIGHT = 0x1001; + public static final int GL_TEXTURE_INDEX_SIZE_EXT = 0x80ED; + public static final int GL_TEXTURE_INTENSITY_SIZE = 0x8061; + public static final int GL_TEXTURE_INTENSITY_SIZE_EXT = 0x8061; + public static final int GL_TEXTURE_INTERNAL_FORMAT = 0x1003; + public static final int GL_TEXTURE_LEQUAL_R_SGIX = 0x819C; + public static final int GL_TEXTURE_LIGHT_EXT = 0x8350; + public static final int GL_TEXTURE_LOD_BIAS_EXT = 0x8501; + public static final int GL_TEXTURE_LOD_BIAS_R_SGIX = 0x8190; + public static final int GL_TEXTURE_LOD_BIAS_S_SGIX = 0x818E; + public static final int GL_TEXTURE_LOD_BIAS_T_SGIX = 0x818F; + public static final int GL_TEXTURE_LUMINANCE_SIZE = 0x8060; + public static final int GL_TEXTURE_LUMINANCE_SIZE_EXT = 0x8060; + public static final int GL_TEXTURE_MAG_FILTER = 0x2800; + public static final int GL_TEXTURE_MATERIAL_FACE_EXT = 0x8351; + public static final int GL_TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352; + public static final int GL_TEXTURE_MATRIX = 0x0BA8; + public static final int GL_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE; + public static final int GL_TEXTURE_MAX_LEVEL = 0x813D; + public static final int GL_TEXTURE_MAX_LEVEL_SGIS = 0x813D; + public static final int GL_TEXTURE_MAX_LOD = 0x813B; + public static final int GL_TEXTURE_MAX_LOD_SGIS = 0x813B; + public static final int GL_TEXTURE_MIN_FILTER = 0x2801; + public static final int GL_TEXTURE_MIN_LOD = 0x813A; + public static final int GL_TEXTURE_MIN_LOD_SGIS = 0x813A; + public static final int GL_TEXTURE_NORMAL_EXT = 0x85AF; + public static final int GL_TEXTURE_PRIORITY = 0x8066; + public static final int GL_TEXTURE_PRIORITY_EXT = 0x8066; + public static final int GL_TEXTURE_RED_SIZE = 0x805C; + public static final int GL_TEXTURE_RED_SIZE_EXT = 0x805C; + public static final int GL_TEXTURE_RESIDENT = 0x8067; + public static final int GL_TEXTURE_RESIDENT_EXT = 0x8067; + public static final int GL_TEXTURE_STACK_DEPTH = 0x0BA5; + public static final int GL_TEXTURE_WIDTH = 0x1000; + public static final int GL_TEXTURE_WRAP_Q_SGIS = 0x8137; + public static final int GL_TEXTURE_WRAP_R = 0x8072; + public static final int GL_TEXTURE_WRAP_R_EXT = 0x8072; + public static final int GL_TEXTURE_WRAP_S = 0x2802; + public static final int GL_TEXTURE_WRAP_T = 0x2803; + public static final int GL_TRANSFORM_BIT = 0x00001000; + public static final int GL_TRANSFORM_HINT_APPLE = 0x85B1; + public static final int GL_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6; + public static final int GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3; + public static final int GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4; + public static final int GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5; + public static final int GL_TRIANGLES = 0x0004; + public static final int GL_TRIANGLE_FAN = 0x0006; + public static final int GL_TRIANGLE_LIST_SUN = 0x81D7; + public static final int GL_TRIANGLE_STRIP = 0x0005; + public static final int GL_UNPACK_ALIGNMENT = 0x0CF5; + public static final int GL_UNPACK_CMYK_HINT_EXT = 0x800F; + public static final int GL_UNPACK_CONSTANT_DATA_SUNX = 0x81D5; + public static final int GL_UNPACK_IMAGE_DEPTH_SGIS = 0x8133; + public static final int GL_UNPACK_IMAGE_HEIGHT = 0x806E; + public static final int GL_UNPACK_IMAGE_HEIGHT_EXT = 0x806E; + public static final int GL_UNPACK_LSB_FIRST = 0x0CF1; + public static final int GL_UNPACK_ROW_LENGTH = 0x0CF2; + public static final int GL_UNPACK_SKIP_IMAGES = 0x806D; + public static final int GL_UNPACK_SKIP_IMAGES_EXT = 0x806D; + public static final int GL_UNPACK_SKIP_PIXELS = 0x0CF4; + public static final int GL_UNPACK_SKIP_ROWS = 0x0CF3; + public static final int GL_UNPACK_SKIP_VOLUMES_SGIS = 0x8132; + public static final int GL_UNPACK_SWAP_BYTES = 0x0CF0; + public static final int GL_UNSIGNED_BYTE = 0x1401; + public static final int GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362; + public static final int GL_UNSIGNED_BYTE_3_3_2 = 0x8032; + public static final int GL_UNSIGNED_BYTE_3_3_2_EXT = 0x8032; + public static final int GL_UNSIGNED_IDENTITY_NV = 0x8536; + public static final int GL_UNSIGNED_INT = 0x1405; + public static final int GL_UNSIGNED_INT_10_10_10_2 = 0x8036; + public static final int GL_UNSIGNED_INT_10_10_10_2_EXT = 0x8036; + public static final int GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368; + public static final int GL_UNSIGNED_INT_8_8_8_8 = 0x8035; + public static final int GL_UNSIGNED_INT_8_8_8_8_EXT = 0x8035; + public static final int GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367; + public static final int GL_UNSIGNED_INVERT_NV = 0x8537; + public static final int GL_UNSIGNED_SHORT = 0x1403; + public static final int GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; + public static final int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; + public static final int GL_UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033; + public static final int GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; + public static final int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; + public static final int GL_UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034; + public static final int GL_UNSIGNED_SHORT_5_6_5 = 0x8363; + public static final int GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364; + public static final int GL_V2F = 0x2A20; + public static final int GL_V3F = 0x2A21; + public static final int GL_VARIABLE_A_NV = 0x8523; + public static final int GL_VARIABLE_B_NV = 0x8524; + public static final int GL_VARIABLE_C_NV = 0x8525; + public static final int GL_VARIABLE_D_NV = 0x8526; + public static final int GL_VARIABLE_E_NV = 0x8527; + public static final int GL_VARIABLE_F_NV = 0x8528; + public static final int GL_VARIABLE_G_NV = 0x8529; + public static final int GL_VATERIAL_SIDE_HINT_PGI = 107052; + public static final int GL_VAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000; + public static final int GL_VAT_AMBIENT_BIT_PGI = 0x00100000; + public static final int GL_VAT_COLOR_INDEXES_BIT_PGI = 0x01000000; + public static final int GL_VAT_DIFFUSE_BIT_PGI = 0x00400000; + public static final int GL_VAT_EMISSION_BIT_PGI = 0x00800000; + public static final int GL_VAT_SHININESS_BIT_PGI = 0x02000000; + public static final int GL_VAT_SPECULAR_BIT_PGI = 0x04000000; + public static final int GL_VAX_VERTEX_HINT_PGI = 107053; + public static final int GL_VDGEFLAG_BIT_PGI = 0x00040000; + public static final int GL_VENDOR = 0x1F00; + public static final int GL_VERSION = 0x1F02; + public static final int GL_VERTEX23_BIT_PGI = 0x00000004; + public static final int GL_VERTEX4_BIT_PGI = 0x00000008; + public static final int GL_VERTEX_ARRAY = 0x8074; + public static final int GL_VERTEX_ARRAY_COUNT_EXT = 0x807D; + public static final int GL_VERTEX_ARRAY_EXT = 0x8074; + public static final int GL_VERTEX_ARRAY_POINTER = 0x808E; + public static final int GL_VERTEX_ARRAY_POINTER_EXT = 0x808E; + public static final int GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E; + public static final int GL_VERTEX_ARRAY_RANGE_NV = 0x851D; + public static final int GL_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521; + public static final int GL_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F; + public static final int GL_VERTEX_ARRAY_SIZE = 0x807A; + public static final int GL_VERTEX_ARRAY_SIZE_EXT = 0x807A; + public static final int GL_VERTEX_ARRAY_STRIDE = 0x807C; + public static final int GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C; + public static final int GL_VERTEX_ARRAY_TYPE = 0x807B; + public static final int GL_VERTEX_ARRAY_TYPE_EXT = 0x807B; + public static final int GL_VERTEX_CONSISTENT_HINT_PGI = 107051; + public static final int GL_VERTEX_DATA_HINT_PGI = 107050; + public static final int GL_VERTEX_WEIGHTING_EXT = 0x8509; + public static final int GL_VERTEX_WEIGHT_ARRAY_EXT = 0x850C; + public static final int GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510; + public static final int GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D; + public static final int GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F; + public static final int GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E; + public static final int GL_VEXCOORD1_BIT_PGI = 0x10000000; + public static final int GL_VEXCOORD2_BIT_PGI = 0x20000000; + public static final int GL_VEXCOORD3_BIT_PGI = 0x40000000; + public static final int GL_VEXCOORD4_BIT_PGI = 0x80000000; + public static final int GL_VIEWPORT = 0x0BA2; + public static final int GL_VIEWPORT_BIT = 0x00000800; + public static final int GL_VNDEX_BIT_PGI = 0x00080000; + public static final int GL_VOLOR3_BIT_PGI = 0x00010000; + public static final int GL_VOLOR4_BIT_PGI = 0x00020000; + public static final int GL_VORMAL_BIT_PGI = 0x08000000; + public static final int GL_WIDE_LINE_HINT_PGI = 107042; + public static final int GL_WRAP_BORDER_SUN = 0x81D4; + public static final int GL_XOR = 0x1506; + public static final int GL_YCRCB_422_SGIX = 0x81BB; + public static final int GL_YCRCB_444_SGIX = 0x81BC; + public static final int GL_ZERO = 0x0; + public static final int GL_ZOOM_X = 0x0D16; + public static final int GL_ZOOM_Y = 0x0D17; +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + + +} + diff --git a/gl4java/GLFunc.java b/gl4java/GLFunc.java new file mode 100644 index 0000000..e80d9da --- /dev/null +++ b/gl4java/GLFunc.java @@ -0,0 +1,7438 @@ +/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!! + + DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!! +*/ + + +/** + * @(#) GLFunc.java + */ + + +package gl4java; + +/** + * The base interface for OpenGL native function mapping + * + * @version 2.00, 21. April 1999 + * @author Sven Goethel + */ +public interface GLFunc + extends GLEnum +{ + +public String glGetString ( int name ) ; + +public String getNativeVendor ( ) ; +public String getNativeVersion ( ) ; + +public String getClassVendor ( ) ; +public String getClassVersion ( ) ; + +public static final String[] GL_PROC_NAMES = { +/** + * C2J Parser Version 1.4 Beta + * Jausoft - Sven Goethel Software Development + * Reading from file: gl-proto-auto.orig . . . + * Destination-Class: gl4java_GLFuncJauJNI ! + */ + + "glClearIndex", + "glClearColor", + "glClear", + "glIndexMask", + "glColorMask", + "glAlphaFunc", + "glBlendFunc", + "glLogicOp", + "glCullFace", + "glFrontFace", + "glPointSize", + "glLineWidth", + "glLineStipple", + "glPolygonMode", + "glPolygonOffset", + "glPolygonStipple", + "glGetPolygonStipple", + "glEdgeFlag", + "glEdgeFlagv", + "glScissor", + "glClipPlane", + "glGetClipPlane", + "glDrawBuffer", + "glReadBuffer", + "glEnable", + "glDisable", + "glIsEnabled", + "glEnableClientState", + "glDisableClientState", + "glGetBooleanv", + "glGetDoublev", + "glGetFloatv", + "glGetIntegerv", + "glPushAttrib", + "glPopAttrib", + "glPushClientAttrib", + "glPopClientAttrib", + "glRenderMode", + "glGetError", + "glFinish", + "glFlush", + "glHint", + "glClearDepth", + "glDepthFunc", + "glDepthMask", + "glDepthRange", + "glClearAccum", + "glAccum", + "glMatrixMode", + "glOrtho", + "glFrustum", + "glViewport", + "glPushMatrix", + "glPopMatrix", + "glLoadIdentity", + "glLoadMatrixd", + "glLoadMatrixf", + "glMultMatrixd", + "glMultMatrixf", + "glRotated", + "glRotatef", + "glScaled", + "glScalef", + "glTranslated", + "glTranslatef", + "glIsList", + "glDeleteLists", + "glGenLists", + "glNewList", + "glEndList", + "glCallList", + "glCallLists", + "glListBase", + "glBegin", + "glEnd", + "glVertex2d", + "glVertex2f", + "glVertex2i", + "glVertex2s", + "glVertex3d", + "glVertex3f", + "glVertex3i", + "glVertex3s", + "glVertex4d", + "glVertex4f", + "glVertex4i", + "glVertex4s", + "glVertex2dv", + "glVertex2fv", + "glVertex2iv", + "glVertex2sv", + "glVertex3dv", + "glVertex3fv", + "glVertex3iv", + "glVertex3sv", + "glVertex4dv", + "glVertex4fv", + "glVertex4iv", + "glVertex4sv", + "glNormal3b", + "glNormal3d", + "glNormal3f", + "glNormal3i", + "glNormal3s", + "glNormal3bv", + "glNormal3dv", + "glNormal3fv", + "glNormal3iv", + "glNormal3sv", + "glIndexd", + "glIndexf", + "glIndexi", + "glIndexs", + "glIndexub", + "glIndexdv", + "glIndexfv", + "glIndexiv", + "glIndexsv", + "glIndexubv", + "glColor3b", + "glColor3d", + "glColor3f", + "glColor3i", + "glColor3s", + "glColor3ub", + "glColor3ui", + "glColor3us", + "glColor4b", + "glColor4d", + "glColor4f", + "glColor4i", + "glColor4s", + "glColor4ub", + "glColor4ui", + "glColor4us", + "glColor3bv", + "glColor3dv", + "glColor3fv", + "glColor3iv", + "glColor3sv", + "glColor3ubv", + "glColor3uiv", + "glColor3usv", + "glColor4bv", + "glColor4dv", + "glColor4fv", + "glColor4iv", + "glColor4sv", + "glColor4ubv", + "glColor4uiv", + "glColor4usv", + "glTexCoord1d", + "glTexCoord1f", + "glTexCoord1i", + "glTexCoord1s", + "glTexCoord2d", + "glTexCoord2f", + "glTexCoord2i", + "glTexCoord2s", + "glTexCoord3d", + "glTexCoord3f", + "glTexCoord3i", + "glTexCoord3s", + "glTexCoord4d", + "glTexCoord4f", + "glTexCoord4i", + "glTexCoord4s", + "glTexCoord1dv", + "glTexCoord1fv", + "glTexCoord1iv", + "glTexCoord1sv", + "glTexCoord2dv", + "glTexCoord2fv", + "glTexCoord2iv", + "glTexCoord2sv", + "glTexCoord3dv", + "glTexCoord3fv", + "glTexCoord3iv", + "glTexCoord3sv", + "glTexCoord4dv", + "glTexCoord4fv", + "glTexCoord4iv", + "glTexCoord4sv", + "glRasterPos2d", + "glRasterPos2f", + "glRasterPos2i", + "glRasterPos2s", + "glRasterPos3d", + "glRasterPos3f", + "glRasterPos3i", + "glRasterPos3s", + "glRasterPos4d", + "glRasterPos4f", + "glRasterPos4i", + "glRasterPos4s", + "glRasterPos2dv", + "glRasterPos2fv", + "glRasterPos2iv", + "glRasterPos2sv", + "glRasterPos3dv", + "glRasterPos3fv", + "glRasterPos3iv", + "glRasterPos3sv", + "glRasterPos4dv", + "glRasterPos4fv", + "glRasterPos4iv", + "glRasterPos4sv", + "glRectd", + "glRectf", + "glRecti", + "glRects", + "glRectdv", + "glRectfv", + "glRectiv", + "glRectsv", + "glVertexPointer", + "glNormalPointer", + "glColorPointer", + "glIndexPointer", + "glTexCoordPointer", + "glEdgeFlagPointer", + "glGetPointerv", + "glArrayElement", + "glDrawArrays", + "glDrawElements", + "glInterleavedArrays", + "glShadeModel", + "glLightf", + "glLighti", + "glLightfv", + "glLightiv", + "glGetLightfv", + "glGetLightiv", + "glLightModelf", + "glLightModeli", + "glLightModelfv", + "glLightModeliv", + "glMaterialf", + "glMateriali", + "glMaterialfv", + "glMaterialiv", + "glGetMaterialfv", + "glGetMaterialiv", + "glColorMaterial", + "glPixelZoom", + "glPixelStoref", + "glPixelStorei", + "glPixelTransferf", + "glPixelTransferi", + "glPixelMapfv", + "glPixelMapuiv", + "glPixelMapusv", + "glGetPixelMapfv", + "glGetPixelMapuiv", + "glGetPixelMapusv", + "glBitmap", + "glReadPixels", + "glDrawPixels", + "glCopyPixels", + "glStencilFunc", + "glStencilMask", + "glStencilOp", + "glClearStencil", + "glTexGend", + "glTexGenf", + "glTexGeni", + "glTexGendv", + "glTexGenfv", + "glTexGeniv", + "glGetTexGendv", + "glGetTexGenfv", + "glGetTexGeniv", + "glTexEnvf", + "glTexEnvi", + "glTexEnvfv", + "glTexEnviv", + "glGetTexEnvfv", + "glGetTexEnviv", + "glTexParameterf", + "glTexParameteri", + "glTexParameterfv", + "glTexParameteriv", + "glGetTexParameterfv", + "glGetTexParameteriv", + "glGetTexLevelParameterfv", + "glGetTexLevelParameteriv", + "glTexImage1D", + "glTexImage2D", + "glGetTexImage", + "glGenTextures", + "glDeleteTextures", + "glBindTexture", + "glPrioritizeTextures", + "glAreTexturesResident", + "glIsTexture", + "glTexSubImage1D", + "glTexSubImage2D", + "glCopyTexImage1D", + "glCopyTexImage2D", + "glCopyTexSubImage1D", + "glCopyTexSubImage2D", + "glMap1d", + "glMap1f", + "glMap2d", + "glMap2f", + "glGetMapdv", + "glGetMapfv", + "glGetMapiv", + "glEvalCoord1d", + "glEvalCoord1f", + "glEvalCoord1dv", + "glEvalCoord1fv", + "glEvalCoord2d", + "glEvalCoord2f", + "glEvalCoord2dv", + "glEvalCoord2fv", + "glMapGrid1d", + "glMapGrid1f", + "glMapGrid2d", + "glMapGrid2f", + "glEvalPoint1", + "glEvalPoint2", + "glEvalMesh1", + "glEvalMesh2", + "glFogf", + "glFogi", + "glFogfv", + "glFogiv", + "glFeedbackBuffer", + "glPassThrough", + "glSelectBuffer", + "glInitNames", + "glLoadName", + "glPushName", + "glPopName", + "glDrawRangeElements", + "glTexImage3D", + "glTexSubImage3D", + "glCopyTexSubImage3D", + "glColorTable", + "glColorSubTable", + "glColorTableParameteriv", + "glColorTableParameterfv", + "glCopyColorSubTable", + "glCopyColorTable", + "glGetColorTable", + "glGetColorTableParameterfv", + "glGetColorTableParameteriv", + "glBlendEquation", + "glBlendColor", + "glHistogram", + "glResetHistogram", + "glGetHistogram", + "glGetHistogramParameterfv", + "glGetHistogramParameteriv", + "glMinmax", + "glResetMinmax", + "glGetMinmax", + "glGetMinmaxParameterfv", + "glGetMinmaxParameteriv", + "glConvolutionFilter1D", + "glConvolutionFilter2D", + "glConvolutionParameterf", + "glConvolutionParameterfv", + "glConvolutionParameteri", + "glConvolutionParameteriv", + "glCopyConvolutionFilter1D", + "glCopyConvolutionFilter2D", + "glGetConvolutionFilter", + "glGetConvolutionParameterfv", + "glGetConvolutionParameteriv", + "glSeparableFilter2D", + "glGetSeparableFilter", + "glBlendColorEXT", + "glPolygonOffsetEXT", + "glTexImage3DEXT", + "glTexSubImage3DEXT", + "glCopyTexSubImage3DEXT", + "glGenTexturesEXT", + "glDeleteTexturesEXT", + "glBindTextureEXT", + "glPrioritizeTexturesEXT", + "glAreTexturesResidentEXT", + "glIsTextureEXT", + "glVertexPointerEXT", + "glNormalPointerEXT", + "glColorPointerEXT", + "glIndexPointerEXT", + "glTexCoordPointerEXT", + "glEdgeFlagPointerEXT", + "glGetPointervEXT", + "glArrayElementEXT", + "glDrawArraysEXT", + "glBlendEquationEXT", + "glPointParameterfEXT", + "glPointParameterfvEXT", + "glColorTableEXT", + "glColorSubTableEXT", + "glGetColorTableEXT", + "glGetColorTableParameterfvEXT", + "glGetColorTableParameterivEXT", + "glLockArraysEXT", + "glUnlockArraysEXT", + "glActiveTextureARB", + "glClientActiveTextureARB", + "glMultiTexCoord1dARB", + "glMultiTexCoord1dvARB", + "glMultiTexCoord1fARB", + "glMultiTexCoord1fvARB", + "glMultiTexCoord1iARB", + "glMultiTexCoord1ivARB", + "glMultiTexCoord1sARB", + "glMultiTexCoord1svARB", + "glMultiTexCoord2dARB", + "glMultiTexCoord2dvARB", + "glMultiTexCoord2fARB", + "glMultiTexCoord2fvARB", + "glMultiTexCoord2iARB", + "glMultiTexCoord2ivARB", + "glMultiTexCoord2sARB", + "glMultiTexCoord2svARB", + "glMultiTexCoord3dARB", + "glMultiTexCoord3dvARB", + "glMultiTexCoord3fARB", + "glMultiTexCoord3fvARB", + "glMultiTexCoord3iARB", + "glMultiTexCoord3ivARB", + "glMultiTexCoord3sARB", + "glMultiTexCoord3svARB", + "glMultiTexCoord4dARB", + "glMultiTexCoord4dvARB", + "glMultiTexCoord4fARB", + "glMultiTexCoord4fvARB", + "glMultiTexCoord4iARB", + "glMultiTexCoord4ivARB", + "glMultiTexCoord4sARB", + "glMultiTexCoord4svARB", +/* C2J Parser Version 1.4 Beta: Java program parsed successfully. */ + null +}; +/** + * 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 : + * <pre> + extern void glClearIndex ( GLfloat c ) ; + * </pre> + */ + public void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClear ( GLbitfield mask ) ; + * </pre> + */ + public void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexMask ( GLuint mask ) ; + * </pre> + */ + public void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ; + * </pre> + */ + public void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAlphaFunc ( GLenum func , GLclampf ref ) ; + * </pre> + */ + public void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ; + * </pre> + */ + public void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLogicOp ( GLenum opcode ) ; + * </pre> + */ + public void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCullFace ( GLenum mode ) ; + * </pre> + */ + public void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrontFace ( GLenum mode ) ; + * </pre> + */ + public void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointSize ( GLfloat size ) ; + * </pre> + */ + public void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineWidth ( GLfloat width ) ; + * </pre> + */ + public void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineStipple ( GLint factor , GLushort pattern ) ; + * </pre> + */ + public void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonMode ( GLenum face , GLenum mode ) ; + * </pre> + */ + public void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ; + * </pre> + */ + public void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonStipple ( const GLubyte * mask ) ; + * </pre> + */ + public void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPolygonStipple ( GLubyte * mask ) ; + * </pre> + */ + public void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlag ( GLboolean flag ) ; + * </pre> + */ + public void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlagv ( const GLboolean * flag ) ; + * </pre> + */ + public void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ; + * </pre> + */ + public void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ; + * </pre> + */ + public void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawBuffer ( GLenum mode ) ; + * </pre> + */ + public void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadBuffer ( GLenum mode ) ; + * </pre> + */ + public void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnable ( GLenum cap ) ; + * </pre> + */ + public void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisable ( GLenum cap ) ; + * </pre> + */ + public void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsEnabled ( GLenum cap ) ; + * </pre> + */ + public boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnableClientState ( GLenum cap ) ; + * </pre> + */ + public void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisableClientState ( GLenum cap ) ; + * </pre> + */ + public void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ; + * </pre> + */ + public void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetDoublev ( GLenum pname , GLdouble * params ) ; + * </pre> + */ + public void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetFloatv ( GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetIntegerv ( GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushAttrib ( GLbitfield mask ) ; + * </pre> + */ + public void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopAttrib ( void ) ; + * </pre> + */ + public void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushClientAttrib ( GLbitfield mask ) ; + * </pre> + */ + public void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopClientAttrib ( void ) ; + * </pre> + */ + public void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLint glRenderMode ( GLenum mode ) ; + * </pre> + */ + public int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLenum glGetError ( void ) ; + * </pre> + */ + public int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFinish ( void ) ; + * </pre> + */ + public void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFlush ( void ) ; + * </pre> + */ + public void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHint ( GLenum target , GLenum mode ) ; + * </pre> + */ + public void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearDepth ( GLclampd depth ) ; + * </pre> + */ + public void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthFunc ( GLenum func ) ; + * </pre> + */ + public void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthMask ( GLboolean flag ) ; + * </pre> + */ + public void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ; + * </pre> + */ + public void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAccum ( GLenum op , GLfloat value ) ; + * </pre> + */ + public void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMatrixMode ( GLenum mode ) ; + * </pre> + */ + public void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushMatrix ( void ) ; + * </pre> + */ + public void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopMatrix ( void ) ; + * </pre> + */ + public void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadIdentity ( void ) ; + * </pre> + */ + public void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsList ( GLuint list ) ; + * </pre> + */ + public boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteLists ( GLuint list , GLsizei range ) ; + * </pre> + */ + public void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLuint glGenLists ( GLsizei range ) ; + * </pre> + */ + public int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNewList ( GLuint list , GLenum mode ) ; + * </pre> + */ + public void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEndList ( void ) ; + * </pre> + */ + public void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallList ( GLuint list ) ; + * </pre> + */ + public void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ; + * </pre> + */ + 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 : + * <pre> + extern void glListBase ( GLuint base ) ; + * </pre> + */ + public void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBegin ( GLenum mode ) ; + * </pre> + */ + public void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnd ( void ) ; + * </pre> + */ + public void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2i ( GLint x , GLint y ) ; + * </pre> + */ + public void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2dv ( const GLdouble * v ) ; + * </pre> + */ + public void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2fv ( const GLfloat * v ) ; + * </pre> + */ + public void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2iv ( const GLint * v ) ; + * </pre> + */ + public void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2sv ( const GLshort * v ) ; + * </pre> + */ + public void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3dv ( const GLdouble * v ) ; + * </pre> + */ + public void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3fv ( const GLfloat * v ) ; + * </pre> + */ + public void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3iv ( const GLint * v ) ; + * </pre> + */ + public void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3sv ( const GLshort * v ) ; + * </pre> + */ + public void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4dv ( const GLdouble * v ) ; + * </pre> + */ + public void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4fv ( const GLfloat * v ) ; + * </pre> + */ + public void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4iv ( const GLint * v ) ; + * </pre> + */ + public void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4sv ( const GLshort * v ) ; + * </pre> + */ + public void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ; + * </pre> + */ + public void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ; + * </pre> + */ + public void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ; + * </pre> + */ + public void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ; + * </pre> + */ + public void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ; + * </pre> + */ + public void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3bv ( const GLbyte * v ) ; + * </pre> + */ + public void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3dv ( const GLdouble * v ) ; + * </pre> + */ + public void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3fv ( const GLfloat * v ) ; + * </pre> + */ + public void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3iv ( const GLint * v ) ; + * </pre> + */ + public void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3sv ( const GLshort * v ) ; + * </pre> + */ + public void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexd ( GLdouble c ) ; + * </pre> + */ + public void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexf ( GLfloat c ) ; + * </pre> + */ + public void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexi ( GLint c ) ; + * </pre> + */ + public void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexs ( GLshort c ) ; + * </pre> + */ + public void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexub ( GLubyte c ) ; + * </pre> + */ + public void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexdv ( const GLdouble * c ) ; + * </pre> + */ + public void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexfv ( const GLfloat * c ) ; + * </pre> + */ + public void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexiv ( const GLint * c ) ; + * </pre> + */ + public void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexsv ( const GLshort * c ) ; + * </pre> + */ + public void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexubv ( const GLubyte * c ) ; + * </pre> + */ + public void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ; + * </pre> + */ + public void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ; + * </pre> + */ + public void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ; + * </pre> + */ + public void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3i ( GLint red , GLint green , GLint blue ) ; + * </pre> + */ + public void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ; + * </pre> + */ + public void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ; + * </pre> + */ + public void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ; + * </pre> + */ + public void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ; + * </pre> + */ + public void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ; + * </pre> + */ + public void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ; + * </pre> + */ + public void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ; + * </pre> + */ + public void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ; + * </pre> + */ + public void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ; + * </pre> + */ + public void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ; + * </pre> + */ + public void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ; + * </pre> + */ + public void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3bv ( const GLbyte * v ) ; + * </pre> + */ + public void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3dv ( const GLdouble * v ) ; + * </pre> + */ + public void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3fv ( const GLfloat * v ) ; + * </pre> + */ + public void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3iv ( const GLint * v ) ; + * </pre> + */ + public void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3sv ( const GLshort * v ) ; + * </pre> + */ + public void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ubv ( const GLubyte * v ) ; + * </pre> + */ + public void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3uiv ( const GLuint * v ) ; + * </pre> + */ + public void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3usv ( const GLushort * v ) ; + * </pre> + */ + public void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4bv ( const GLbyte * v ) ; + * </pre> + */ + public void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4dv ( const GLdouble * v ) ; + * </pre> + */ + public void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4fv ( const GLfloat * v ) ; + * </pre> + */ + public void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4iv ( const GLint * v ) ; + * </pre> + */ + public void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4sv ( const GLshort * v ) ; + * </pre> + */ + public void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ubv ( const GLubyte * v ) ; + * </pre> + */ + public void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4uiv ( const GLuint * v ) ; + * </pre> + */ + public void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4usv ( const GLushort * v ) ; + * </pre> + */ + public void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1d ( GLdouble s ) ; + * </pre> + */ + public void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1f ( GLfloat s ) ; + * </pre> + */ + public void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1i ( GLint s ) ; + * </pre> + */ + public void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1s ( GLshort s ) ; + * </pre> + */ + public void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2d ( GLdouble s , GLdouble t ) ; + * </pre> + */ + public void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2f ( GLfloat s , GLfloat t ) ; + * </pre> + */ + public void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2i ( GLint s , GLint t ) ; + * </pre> + */ + public void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2s ( GLshort s , GLshort t ) ; + * </pre> + */ + public void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ; + * </pre> + */ + public void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1dv ( const GLdouble * v ) ; + * </pre> + */ + public void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1fv ( const GLfloat * v ) ; + * </pre> + */ + public void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1iv ( const GLint * v ) ; + * </pre> + */ + public void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1sv ( const GLshort * v ) ; + * </pre> + */ + public void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2dv ( const GLdouble * v ) ; + * </pre> + */ + public void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2fv ( const GLfloat * v ) ; + * </pre> + */ + public void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2iv ( const GLint * v ) ; + * </pre> + */ + public void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2sv ( const GLshort * v ) ; + * </pre> + */ + public void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3dv ( const GLdouble * v ) ; + * </pre> + */ + public void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3fv ( const GLfloat * v ) ; + * </pre> + */ + public void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3iv ( const GLint * v ) ; + * </pre> + */ + public void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3sv ( const GLshort * v ) ; + * </pre> + */ + public void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4dv ( const GLdouble * v ) ; + * </pre> + */ + public void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4fv ( const GLfloat * v ) ; + * </pre> + */ + public void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4iv ( const GLint * v ) ; + * </pre> + */ + public void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4sv ( const GLshort * v ) ; + * </pre> + */ + public void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2i ( GLint x , GLint y ) ; + * </pre> + */ + public void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2dv ( const GLdouble * v ) ; + * </pre> + */ + public void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2fv ( const GLfloat * v ) ; + * </pre> + */ + public void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2iv ( const GLint * v ) ; + * </pre> + */ + public void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2sv ( const GLshort * v ) ; + * </pre> + */ + public void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3dv ( const GLdouble * v ) ; + * </pre> + */ + public void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3fv ( const GLfloat * v ) ; + * </pre> + */ + public void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3iv ( const GLint * v ) ; + * </pre> + */ + public void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3sv ( const GLshort * v ) ; + * </pre> + */ + public void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4dv ( const GLdouble * v ) ; + * </pre> + */ + public void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4fv ( const GLfloat * v ) ; + * </pre> + */ + public void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4iv ( const GLint * v ) ; + * </pre> + */ + public void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4sv ( const GLshort * v ) ; + * </pre> + */ + public void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ; + * </pre> + */ + public void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ; + * </pre> + */ + public void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ; + * </pre> + */ + public void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ; + * </pre> + */ + public void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ; + * </pre> + */ + public void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ; + * </pre> + */ + public void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ; + * </pre> + */ + public void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ; + * </pre> + */ + public void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetPointerv ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElement ( GLint i ) ; + * </pre> + */ + public void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ; + * </pre> + */ + 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 : + * <pre> + extern void glShadeModel ( GLenum mode ) ; + * </pre> + */ + public void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLighti ( GLenum light , GLenum pname , GLint param ) ; + * </pre> + */ + public void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeli ( GLenum pname , GLint param ) ; + * </pre> + */ + public void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeliv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ; + * </pre> + */ + public void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMaterial ( GLenum face , GLenum mode ) ; + * </pre> + */ + public void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ; + * </pre> + */ + public void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStoref ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStorei ( GLenum pname , GLint param ) ; + * </pre> + */ + public void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferi ( GLenum pname , GLint param ) ; + * </pre> + */ + public void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ; + * </pre> + */ + public void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ; + * </pre> + */ + public void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ; + * </pre> + */ + public void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ; + * </pre> + */ + public void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ; + * </pre> + */ + public void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ; + * </pre> + */ + public void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ; + * </pre> + */ + public void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ; + * </pre> + */ + public void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ; + * </pre> + */ + public void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilMask ( GLuint mask ) ; + * </pre> + */ + public void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ; + * </pre> + */ + public void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearStencil ( GLint s ) ; + * </pre> + */ + public void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ; + * </pre> + */ + public void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ; + * </pre> + */ + public void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ; + * </pre> + */ + public void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ; + * </pre> + */ + public void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGenTextures ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTexture ( GLenum target , GLuint texture ) ; + * </pre> + */ + public void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTexture ( GLuint texture ) ; + * </pre> + */ + public boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ; + * </pre> + */ + public void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ; + * </pre> + */ + public void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ; + * </pre> + */ + public void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ; + * </pre> + */ + public void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ; + * </pre> + */ + public void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ; + * </pre> + */ + public void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ; + * </pre> + */ + public void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1d ( GLdouble u ) ; + * </pre> + */ + public void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1f ( GLfloat u ) ; + * </pre> + */ + public void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1dv ( const GLdouble * u ) ; + * </pre> + */ + public void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1fv ( const GLfloat * u ) ; + * </pre> + */ + public void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ; + * </pre> + */ + public void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ; + * </pre> + */ + public void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2dv ( const GLdouble * u ) ; + * </pre> + */ + public void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2fv ( const GLfloat * u ) ; + * </pre> + */ + public void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ; + * </pre> + */ + public void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ; + * </pre> + */ + public void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ; + * </pre> + */ + public void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ; + * </pre> + */ + public void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint1 ( GLint i ) ; + * </pre> + */ + public void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint2 ( GLint i , GLint j ) ; + * </pre> + */ + public void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ; + * </pre> + */ + public void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ; + * </pre> + */ + public void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogi ( GLenum pname , GLint param ) ; + * </pre> + */ + public void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogiv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ; + * </pre> + */ + public void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPassThrough ( GLfloat token ) ; + * </pre> + */ + public void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ; + * </pre> + */ + public void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glInitNames ( void ) ; + * </pre> + */ + public void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadName ( GLuint name ) ; + * </pre> + */ + public void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushName ( GLuint name ) ; + * </pre> + */ + public void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopName ( void ) ; + * </pre> + */ + public void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glCopyTexSubImage3D ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquation ( GLenum mode ) ; + * </pre> + */ + public void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetHistogram ( GLenum target ) ; + * </pre> + */ + public void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetMinmax ( GLenum target ) ; + * </pre> + */ + public void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ; + * </pre> + */ + public void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ; + * </pre> + */ + public void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ; + * </pre> + */ + 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 : + * <pre> + extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ; + * </pre> + */ + public void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public void glCopyTexSubImage3DEXT ( + int target, + int level, + int xoffset, + int yoffset, + int zoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTextureEXT ( GLenum target , GLuint texture ) ; + * </pre> + */ + public void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTextureEXT ( GLuint texture ) ; + * </pre> + */ + public boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ; + * </pre> + */ + public void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPointervEXT ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElementEXT ( GLint i ) ; + * </pre> + */ + public void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquationEXT ( GLenum mode ) ; + * </pre> + */ + public void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLockArraysEXT ( GLint first , GLsizei count ) ; + * </pre> + */ + public void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glUnlockArraysEXT ( void ) ; + * </pre> + */ + public void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClientActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ; + * </pre> + */ + public void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ; + * </pre> + */ + public void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ; + * </pre> + */ + public void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ; + * </pre> + */ + public void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ; + * </pre> + */ + public void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ; + * </pre> + */ + public void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ; + * </pre> + */ + public void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ; + * </pre> + */ + public void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ; + * </pre> + */ + public void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + 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 : + * <pre> + extern void glClearIndex ( GLfloat c ) ; + * </pre> + */ + public final native void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public final native void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClear ( GLbitfield mask ) ; + * </pre> + */ + public final native void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexMask ( GLuint mask ) ; + * </pre> + */ + public final native void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ; + * </pre> + */ + public final native void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAlphaFunc ( GLenum func , GLclampf ref ) ; + * </pre> + */ + public final native void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ; + * </pre> + */ + public final native void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLogicOp ( GLenum opcode ) ; + * </pre> + */ + public final native void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCullFace ( GLenum mode ) ; + * </pre> + */ + public final native void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrontFace ( GLenum mode ) ; + * </pre> + */ + public final native void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointSize ( GLfloat size ) ; + * </pre> + */ + public final native void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineWidth ( GLfloat width ) ; + * </pre> + */ + public final native void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineStipple ( GLint factor , GLushort pattern ) ; + * </pre> + */ + public final native void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonMode ( GLenum face , GLenum mode ) ; + * </pre> + */ + public final native void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ; + * </pre> + */ + public final native void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonStipple ( const GLubyte * mask ) ; + * </pre> + */ + public final native void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPolygonStipple ( GLubyte * mask ) ; + * </pre> + */ + public final native void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlag ( GLboolean flag ) ; + * </pre> + */ + public final native void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlagv ( const GLboolean * flag ) ; + * </pre> + */ + public final native void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public final native void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ; + * </pre> + */ + public final native void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ; + * </pre> + */ + public final native void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawBuffer ( GLenum mode ) ; + * </pre> + */ + public final native void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadBuffer ( GLenum mode ) ; + * </pre> + */ + public final native void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnable ( GLenum cap ) ; + * </pre> + */ + public final native void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisable ( GLenum cap ) ; + * </pre> + */ + public final native void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsEnabled ( GLenum cap ) ; + * </pre> + */ + public final native boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnableClientState ( GLenum cap ) ; + * </pre> + */ + public final native void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisableClientState ( GLenum cap ) ; + * </pre> + */ + public final native void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ; + * </pre> + */ + public final native void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetDoublev ( GLenum pname , GLdouble * params ) ; + * </pre> + */ + public final native void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetFloatv ( GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetIntegerv ( GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushAttrib ( GLbitfield mask ) ; + * </pre> + */ + public final native void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopAttrib ( void ) ; + * </pre> + */ + public final native void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushClientAttrib ( GLbitfield mask ) ; + * </pre> + */ + public final native void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopClientAttrib ( void ) ; + * </pre> + */ + public final native void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLint glRenderMode ( GLenum mode ) ; + * </pre> + */ + public final native int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLenum glGetError ( void ) ; + * </pre> + */ + public final native int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFinish ( void ) ; + * </pre> + */ + public final native void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFlush ( void ) ; + * </pre> + */ + public final native void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHint ( GLenum target , GLenum mode ) ; + * </pre> + */ + public final native void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearDepth ( GLclampd depth ) ; + * </pre> + */ + public final native void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthFunc ( GLenum func ) ; + * </pre> + */ + public final native void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthMask ( GLboolean flag ) ; + * </pre> + */ + public final native void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ; + * </pre> + */ + public final native void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public final native void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAccum ( GLenum op , GLfloat value ) ; + * </pre> + */ + public final native void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMatrixMode ( GLenum mode ) ; + * </pre> + */ + public final native void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public final native void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public final native void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public final native void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushMatrix ( void ) ; + * </pre> + */ + public final native void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopMatrix ( void ) ; + * </pre> + */ + public final native void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadIdentity ( void ) ; + * </pre> + */ + public final native void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public final native void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public final native void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public final native void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public final native void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public final native void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public final native void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public final native void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsList ( GLuint list ) ; + * </pre> + */ + public final native boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteLists ( GLuint list , GLsizei range ) ; + * </pre> + */ + public final native void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLuint glGenLists ( GLsizei range ) ; + * </pre> + */ + public final native int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNewList ( GLuint list , GLenum mode ) ; + * </pre> + */ + public final native void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEndList ( void ) ; + * </pre> + */ + public final native void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallList ( GLuint list ) ; + * </pre> + */ + public final native void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ; + * </pre> + */ + 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 : + * <pre> + extern void glListBase ( GLuint base ) ; + * </pre> + */ + public final native void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBegin ( GLenum mode ) ; + * </pre> + */ + public final native void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnd ( void ) ; + * </pre> + */ + public final native void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public final native void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public final native void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2i ( GLint x , GLint y ) ; + * </pre> + */ + public final native void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public final native void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public final native void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public final native void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public final native void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public final native void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public final native void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public final native void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public final native void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2iv ( const GLint * v ) ; + * </pre> + */ + public final native void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3iv ( const GLint * v ) ; + * </pre> + */ + public final native void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4iv ( const GLint * v ) ; + * </pre> + */ + public final native void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ; + * </pre> + */ + public final native void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ; + * </pre> + */ + public final native void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ; + * </pre> + */ + public final native void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ; + * </pre> + */ + public final native void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ; + * </pre> + */ + public final native void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3bv ( const GLbyte * v ) ; + * </pre> + */ + public final native void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3iv ( const GLint * v ) ; + * </pre> + */ + public final native void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexd ( GLdouble c ) ; + * </pre> + */ + public final native void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexf ( GLfloat c ) ; + * </pre> + */ + public final native void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexi ( GLint c ) ; + * </pre> + */ + public final native void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexs ( GLshort c ) ; + * </pre> + */ + public final native void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexub ( GLubyte c ) ; + * </pre> + */ + public final native void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexdv ( const GLdouble * c ) ; + * </pre> + */ + public final native void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexfv ( const GLfloat * c ) ; + * </pre> + */ + public final native void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexiv ( const GLint * c ) ; + * </pre> + */ + public final native void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexsv ( const GLshort * c ) ; + * </pre> + */ + public final native void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexubv ( const GLubyte * c ) ; + * </pre> + */ + public final native void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ; + * </pre> + */ + public final native void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ; + * </pre> + */ + public final native void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ; + * </pre> + */ + public final native void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3i ( GLint red , GLint green , GLint blue ) ; + * </pre> + */ + public final native void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ; + * </pre> + */ + public final native void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ; + * </pre> + */ + public final native void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ; + * </pre> + */ + public final native void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ; + * </pre> + */ + public final native void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ; + * </pre> + */ + public final native void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ; + * </pre> + */ + public final native void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public final native void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ; + * </pre> + */ + public final native void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ; + * </pre> + */ + public final native void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ; + * </pre> + */ + public final native void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ; + * </pre> + */ + public final native void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ; + * </pre> + */ + public final native void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3bv ( const GLbyte * v ) ; + * </pre> + */ + public final native void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3iv ( const GLint * v ) ; + * </pre> + */ + public final native void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ubv ( const GLubyte * v ) ; + * </pre> + */ + public final native void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3uiv ( const GLuint * v ) ; + * </pre> + */ + public final native void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3usv ( const GLushort * v ) ; + * </pre> + */ + public final native void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4bv ( const GLbyte * v ) ; + * </pre> + */ + public final native void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4iv ( const GLint * v ) ; + * </pre> + */ + public final native void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ubv ( const GLubyte * v ) ; + * </pre> + */ + public final native void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4uiv ( const GLuint * v ) ; + * </pre> + */ + public final native void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4usv ( const GLushort * v ) ; + * </pre> + */ + public final native void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1d ( GLdouble s ) ; + * </pre> + */ + public final native void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1f ( GLfloat s ) ; + * </pre> + */ + public final native void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1i ( GLint s ) ; + * </pre> + */ + public final native void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1s ( GLshort s ) ; + * </pre> + */ + public final native void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2d ( GLdouble s , GLdouble t ) ; + * </pre> + */ + public final native void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2f ( GLfloat s , GLfloat t ) ; + * </pre> + */ + public final native void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2i ( GLint s , GLint t ) ; + * </pre> + */ + public final native void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2s ( GLshort s , GLshort t ) ; + * </pre> + */ + public final native void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public final native void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public final native void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ; + * </pre> + */ + public final native void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public final native void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public final native void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public final native void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public final native void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public final native void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1iv ( const GLint * v ) ; + * </pre> + */ + public final native void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2iv ( const GLint * v ) ; + * </pre> + */ + public final native void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3iv ( const GLint * v ) ; + * </pre> + */ + public final native void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4iv ( const GLint * v ) ; + * </pre> + */ + public final native void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public final native void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public final native void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2i ( GLint x , GLint y ) ; + * </pre> + */ + public final native void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public final native void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public final native void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public final native void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public final native void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public final native void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public final native void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public final native void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public final native void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2iv ( const GLint * v ) ; + * </pre> + */ + public final native void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3iv ( const GLint * v ) ; + * </pre> + */ + public final native void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4dv ( const GLdouble * v ) ; + * </pre> + */ + public final native void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4fv ( const GLfloat * v ) ; + * </pre> + */ + public final native void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4iv ( const GLint * v ) ; + * </pre> + */ + public final native void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4sv ( const GLshort * v ) ; + * </pre> + */ + public final native void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ; + * </pre> + */ + public final native void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ; + * </pre> + */ + public final native void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ; + * </pre> + */ + public final native void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ; + * </pre> + */ + public final native void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ; + * </pre> + */ + public final native void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ; + * </pre> + */ + public final native void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ; + * </pre> + */ + public final native void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ; + * </pre> + */ + public final native void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetPointerv ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElement ( GLint i ) ; + * </pre> + */ + public final native void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public final native void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ; + * </pre> + */ + 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 : + * <pre> + extern void glShadeModel ( GLenum mode ) ; + * </pre> + */ + public final native void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLighti ( GLenum light , GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeli ( GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeliv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMaterial ( GLenum face , GLenum mode ) ; + * </pre> + */ + public final native void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ; + * </pre> + */ + public final native void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStoref ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStorei ( GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferi ( GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ; + * </pre> + */ + public final native void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ; + * </pre> + */ + public final native void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ; + * </pre> + */ + public final native void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ; + * </pre> + */ + public final native void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ; + * </pre> + */ + public final native void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ; + * </pre> + */ + public final native void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ; + * </pre> + */ + public final native void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ; + * </pre> + */ + public final native void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ; + * </pre> + */ + public final native void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilMask ( GLuint mask ) ; + * </pre> + */ + public final native void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ; + * </pre> + */ + public final native void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearStencil ( GLint s ) ; + * </pre> + */ + public final native void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ; + * </pre> + */ + public final native void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ; + * </pre> + */ + public final native void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ; + * </pre> + */ + public final native void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGenTextures ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public final native void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public final native void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTexture ( GLenum target , GLuint texture ) ; + * </pre> + */ + public final native void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public final native void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public final native boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTexture ( GLuint texture ) ; + * </pre> + */ + public final native boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ; + * </pre> + */ + public final native void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ; + * </pre> + */ + public final native void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public final native void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public final native void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ; + * </pre> + */ + public final native void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ; + * </pre> + */ + public final native void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ; + * </pre> + */ + public final native void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ; + * </pre> + */ + public final native void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ; + * </pre> + */ + public final native void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1d ( GLdouble u ) ; + * </pre> + */ + public final native void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1f ( GLfloat u ) ; + * </pre> + */ + public final native void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1dv ( const GLdouble * u ) ; + * </pre> + */ + public final native void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1fv ( const GLfloat * u ) ; + * </pre> + */ + public final native void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ; + * </pre> + */ + public final native void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ; + * </pre> + */ + public final native void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2dv ( const GLdouble * u ) ; + * </pre> + */ + public final native void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2fv ( const GLfloat * u ) ; + * </pre> + */ + public final native void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ; + * </pre> + */ + public final native void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ; + * </pre> + */ + public final native void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ; + * </pre> + */ + public final native void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ; + * </pre> + */ + public final native void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint1 ( GLint i ) ; + * </pre> + */ + public final native void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint2 ( GLint i , GLint j ) ; + * </pre> + */ + public final native void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ; + * </pre> + */ + public final native void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ; + * </pre> + */ + public final native void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogi ( GLenum pname , GLint param ) ; + * </pre> + */ + public final native void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogiv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ; + * </pre> + */ + public final native void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPassThrough ( GLfloat token ) ; + * </pre> + */ + public final native void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ; + * </pre> + */ + public final native void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glInitNames ( void ) ; + * </pre> + */ + public final native void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadName ( GLuint name ) ; + * </pre> + */ + public final native void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushName ( GLuint name ) ; + * </pre> + */ + public final native void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopName ( void ) ; + * </pre> + */ + public final native void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public final native void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public final native void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquation ( GLenum mode ) ; + * </pre> + */ + public final native void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public final native void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public final native void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetHistogram ( GLenum target ) ; + * </pre> + */ + public final native void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public final native void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetMinmax ( GLenum target ) ; + * </pre> + */ + public final native void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ; + * </pre> + */ + public final native void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ; + * </pre> + */ + public final native void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public final native void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public final native void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public final native void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ; + * </pre> + */ + 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 : + * <pre> + extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public final native void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ; + * </pre> + */ + public final native void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public final native void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public final native void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTextureEXT ( GLenum target , GLuint texture ) ; + * </pre> + */ + public final native void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public final native void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public final native boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTextureEXT ( GLuint texture ) ; + * </pre> + */ + public final native boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ; + * </pre> + */ + public final native void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPointervEXT ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElementEXT ( GLint i ) ; + * </pre> + */ + public final native void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public final native void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquationEXT ( GLenum mode ) ; + * </pre> + */ + public final native void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public final native void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public final native void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public final native void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public final native void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLockArraysEXT ( GLint first , GLsizei count ) ; + * </pre> + */ + public final native void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glUnlockArraysEXT ( void ) ; + * </pre> + */ + public final native void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public final native void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClientActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public final native void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ; + * </pre> + */ + public final native void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public final native void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ; + * </pre> + */ + public final native void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public final native void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ; + * </pre> + */ + public final native void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public final native void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ; + * </pre> + */ + public final native void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public final native void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ; + * </pre> + */ + public final native void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public final native void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ; + * </pre> + */ + public final native void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public final native void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ; + * </pre> + */ + public final native void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public final native void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ; + * </pre> + */ + public final native void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public final native void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public final native void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public final native void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public final native void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public final native void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ; + * </pre> + */ + public final native void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public final native void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public final native void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public final native void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public final native void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public final native void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public final native void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public final native void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public final native void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public final native void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public final native void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + 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 : + * <pre> + extern void glClearIndex ( GLfloat c ) ; + * </pre> + */ + public native void glClearIndex ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public native void glClearColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClear ( GLbitfield mask ) ; + * </pre> + */ + public native void glClear ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexMask ( GLuint mask ) ; + * </pre> + */ + public native void glIndexMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ; + * </pre> + */ + public native void glColorMask ( + boolean red, + boolean green, + boolean blue, + boolean alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAlphaFunc ( GLenum func , GLclampf ref ) ; + * </pre> + */ + public native void glAlphaFunc ( + int func, + float ref + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ; + * </pre> + */ + public native void glBlendFunc ( + int sfactor, + int dfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLogicOp ( GLenum opcode ) ; + * </pre> + */ + public native void glLogicOp ( + int opcode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCullFace ( GLenum mode ) ; + * </pre> + */ + public native void glCullFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrontFace ( GLenum mode ) ; + * </pre> + */ + public native void glFrontFace ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointSize ( GLfloat size ) ; + * </pre> + */ + public native void glPointSize ( + float size + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineWidth ( GLfloat width ) ; + * </pre> + */ + public native void glLineWidth ( + float width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLineStipple ( GLint factor , GLushort pattern ) ; + * </pre> + */ + public native void glLineStipple ( + int factor, + short pattern + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonMode ( GLenum face , GLenum mode ) ; + * </pre> + */ + public native void glPolygonMode ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ; + * </pre> + */ + public native void glPolygonOffset ( + float factor, + float units + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonStipple ( const GLubyte * mask ) ; + * </pre> + */ + public native void glPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPolygonStipple ( GLubyte * mask ) ; + * </pre> + */ + public native void glGetPolygonStipple ( + byte[] mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlag ( GLboolean flag ) ; + * </pre> + */ + public native void glEdgeFlag ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEdgeFlagv ( const GLboolean * flag ) ; + * </pre> + */ + public native void glEdgeFlagv ( + boolean[] flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public native void glScissor ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ; + * </pre> + */ + public native void glClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ; + * </pre> + */ + public native void glGetClipPlane ( + int plane, + double[] equation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawBuffer ( GLenum mode ) ; + * </pre> + */ + public native void glDrawBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadBuffer ( GLenum mode ) ; + * </pre> + */ + public native void glReadBuffer ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnable ( GLenum cap ) ; + * </pre> + */ + public native void glEnable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisable ( GLenum cap ) ; + * </pre> + */ + public native void glDisable ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsEnabled ( GLenum cap ) ; + * </pre> + */ + public native boolean glIsEnabled ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnableClientState ( GLenum cap ) ; + * </pre> + */ + public native void glEnableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDisableClientState ( GLenum cap ) ; + * </pre> + */ + public native void glDisableClientState ( + int cap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ; + * </pre> + */ + public native void glGetBooleanv ( + int pname, + boolean[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetDoublev ( GLenum pname , GLdouble * params ) ; + * </pre> + */ + public native void glGetDoublev ( + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetFloatv ( GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetFloatv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetIntegerv ( GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetIntegerv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushAttrib ( GLbitfield mask ) ; + * </pre> + */ + public native void glPushAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopAttrib ( void ) ; + * </pre> + */ + public native void glPopAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushClientAttrib ( GLbitfield mask ) ; + * </pre> + */ + public native void glPushClientAttrib ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopClientAttrib ( void ) ; + * </pre> + */ + public native void glPopClientAttrib ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLint glRenderMode ( GLenum mode ) ; + * </pre> + */ + public native int glRenderMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLenum glGetError ( void ) ; + * </pre> + */ + public native int glGetError ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFinish ( void ) ; + * </pre> + */ + public native void glFinish ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFlush ( void ) ; + * </pre> + */ + public native void glFlush ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHint ( GLenum target , GLenum mode ) ; + * </pre> + */ + public native void glHint ( + int target, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearDepth ( GLclampd depth ) ; + * </pre> + */ + public native void glClearDepth ( + double depth + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthFunc ( GLenum func ) ; + * </pre> + */ + public native void glDepthFunc ( + int func + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthMask ( GLboolean flag ) ; + * </pre> + */ + public native void glDepthMask ( + boolean flag + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ; + * </pre> + */ + public native void glDepthRange ( + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public native void glClearAccum ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glAccum ( GLenum op , GLfloat value ) ; + * </pre> + */ + public native void glAccum ( + int op, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMatrixMode ( GLenum mode ) ; + * </pre> + */ + public native void glMatrixMode ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public native void glOrtho ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ; + * </pre> + */ + public native void glFrustum ( + double left, + double right, + double bottom, + double top, + double near_val, + double far_val + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public native void glViewport ( + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushMatrix ( void ) ; + * </pre> + */ + public native void glPushMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopMatrix ( void ) ; + * </pre> + */ + public native void glPopMatrix ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadIdentity ( void ) ; + * </pre> + */ + public native void glLoadIdentity ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public native void glLoadMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public native void glLoadMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixd ( const GLdouble * m ) ; + * </pre> + */ + public native void glMultMatrixd ( + double[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultMatrixf ( const GLfloat * m ) ; + * </pre> + */ + public native void glMultMatrixf ( + float[] m + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void glRotated ( + double angle, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public native void glRotatef ( + float angle, + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void glScaled ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public native void glScalef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void glTranslated ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public native void glTranslatef ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsList ( GLuint list ) ; + * </pre> + */ + public native boolean glIsList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteLists ( GLuint list , GLsizei range ) ; + * </pre> + */ + public native void glDeleteLists ( + int list, + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLuint glGenLists ( GLsizei range ) ; + * </pre> + */ + public native int glGenLists ( + int range + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNewList ( GLuint list , GLenum mode ) ; + * </pre> + */ + public native void glNewList ( + int list, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEndList ( void ) ; + * </pre> + */ + public native void glEndList ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallList ( GLuint list ) ; + * </pre> + */ + public native void glCallList ( + int list + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ; + * </pre> + */ + 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 : + * <pre> + extern void glListBase ( GLuint base ) ; + * </pre> + */ + public native void glListBase ( + int base + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBegin ( GLenum mode ) ; + * </pre> + */ + public native void glBegin ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEnd ( void ) ; + * </pre> + */ + public native void glEnd ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public native void glVertex2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public native void glVertex2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2i ( GLint x , GLint y ) ; + * </pre> + */ + public native void glVertex2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public native void glVertex2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void glVertex3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public native void glVertex3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public native void glVertex3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public native void glVertex3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public native void glVertex4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public native void glVertex4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public native void glVertex4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public native void glVertex4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glVertex2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glVertex2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2iv ( const GLint * v ) ; + * </pre> + */ + public native void glVertex2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex2sv ( const GLshort * v ) ; + * </pre> + */ + public native void glVertex2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glVertex3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glVertex3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3iv ( const GLint * v ) ; + * </pre> + */ + public native void glVertex3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex3sv ( const GLshort * v ) ; + * </pre> + */ + public native void glVertex3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glVertex4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glVertex4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4iv ( const GLint * v ) ; + * </pre> + */ + public native void glVertex4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertex4sv ( const GLshort * v ) ; + * </pre> + */ + public native void glVertex4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ; + * </pre> + */ + public native void glNormal3b ( + byte nx, + byte ny, + byte nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ; + * </pre> + */ + public native void glNormal3d ( + double nx, + double ny, + double nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ; + * </pre> + */ + public native void glNormal3f ( + float nx, + float ny, + float nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ; + * </pre> + */ + public native void glNormal3i ( + int nx, + int ny, + int nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ; + * </pre> + */ + public native void glNormal3s ( + short nx, + short ny, + short nz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3bv ( const GLbyte * v ) ; + * </pre> + */ + public native void glNormal3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glNormal3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glNormal3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3iv ( const GLint * v ) ; + * </pre> + */ + public native void glNormal3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glNormal3sv ( const GLshort * v ) ; + * </pre> + */ + public native void glNormal3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexd ( GLdouble c ) ; + * </pre> + */ + public native void glIndexd ( + double c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexf ( GLfloat c ) ; + * </pre> + */ + public native void glIndexf ( + float c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexi ( GLint c ) ; + * </pre> + */ + public native void glIndexi ( + int c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexs ( GLshort c ) ; + * </pre> + */ + public native void glIndexs ( + short c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexub ( GLubyte c ) ; + * </pre> + */ + public native void glIndexub ( + byte c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexdv ( const GLdouble * c ) ; + * </pre> + */ + public native void glIndexdv ( + double[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexfv ( const GLfloat * c ) ; + * </pre> + */ + public native void glIndexfv ( + float[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexiv ( const GLint * c ) ; + * </pre> + */ + public native void glIndexiv ( + int[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexsv ( const GLshort * c ) ; + * </pre> + */ + public native void glIndexsv ( + short[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glIndexubv ( const GLubyte * c ) ; + * </pre> + */ + public native void glIndexubv ( + byte[] c + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ; + * </pre> + */ + public native void glColor3b ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ; + * </pre> + */ + public native void glColor3d ( + double red, + double green, + double blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ; + * </pre> + */ + public native void glColor3f ( + float red, + float green, + float blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3i ( GLint red , GLint green , GLint blue ) ; + * </pre> + */ + public native void glColor3i ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ; + * </pre> + */ + public native void glColor3s ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ; + * </pre> + */ + public native void glColor3ub ( + byte red, + byte green, + byte blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ; + * </pre> + */ + public native void glColor3ui ( + int red, + int green, + int blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ; + * </pre> + */ + public native void glColor3us ( + short red, + short green, + short blue + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ; + * </pre> + */ + public native void glColor4b ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ; + * </pre> + */ + public native void glColor4d ( + double red, + double green, + double blue, + double alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ; + * </pre> + */ + public native void glColor4f ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ; + * </pre> + */ + public native void glColor4i ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ; + * </pre> + */ + public native void glColor4s ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ; + * </pre> + */ + public native void glColor4ub ( + byte red, + byte green, + byte blue, + byte alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ; + * </pre> + */ + public native void glColor4ui ( + int red, + int green, + int blue, + int alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ; + * </pre> + */ + public native void glColor4us ( + short red, + short green, + short blue, + short alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3bv ( const GLbyte * v ) ; + * </pre> + */ + public native void glColor3bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glColor3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glColor3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3iv ( const GLint * v ) ; + * </pre> + */ + public native void glColor3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3sv ( const GLshort * v ) ; + * </pre> + */ + public native void glColor3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3ubv ( const GLubyte * v ) ; + * </pre> + */ + public native void glColor3ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3uiv ( const GLuint * v ) ; + * </pre> + */ + public native void glColor3uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor3usv ( const GLushort * v ) ; + * </pre> + */ + public native void glColor3usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4bv ( const GLbyte * v ) ; + * </pre> + */ + public native void glColor4bv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glColor4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glColor4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4iv ( const GLint * v ) ; + * </pre> + */ + public native void glColor4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4sv ( const GLshort * v ) ; + * </pre> + */ + public native void glColor4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4ubv ( const GLubyte * v ) ; + * </pre> + */ + public native void glColor4ubv ( + byte[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4uiv ( const GLuint * v ) ; + * </pre> + */ + public native void glColor4uiv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColor4usv ( const GLushort * v ) ; + * </pre> + */ + public native void glColor4usv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1d ( GLdouble s ) ; + * </pre> + */ + public native void glTexCoord1d ( + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1f ( GLfloat s ) ; + * </pre> + */ + public native void glTexCoord1f ( + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1i ( GLint s ) ; + * </pre> + */ + public native void glTexCoord1i ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1s ( GLshort s ) ; + * </pre> + */ + public native void glTexCoord1s ( + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2d ( GLdouble s , GLdouble t ) ; + * </pre> + */ + public native void glTexCoord2d ( + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2f ( GLfloat s , GLfloat t ) ; + * </pre> + */ + public native void glTexCoord2f ( + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2i ( GLint s , GLint t ) ; + * </pre> + */ + public native void glTexCoord2i ( + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2s ( GLshort s , GLshort t ) ; + * </pre> + */ + public native void glTexCoord2s ( + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public native void glTexCoord3d ( + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public native void glTexCoord3f ( + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ; + * </pre> + */ + public native void glTexCoord3i ( + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public native void glTexCoord3s ( + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public native void glTexCoord4d ( + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public native void glTexCoord4f ( + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public native void glTexCoord4i ( + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public native void glTexCoord4s ( + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glTexCoord1dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glTexCoord1fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1iv ( const GLint * v ) ; + * </pre> + */ + public native void glTexCoord1iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord1sv ( const GLshort * v ) ; + * </pre> + */ + public native void glTexCoord1sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glTexCoord2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glTexCoord2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2iv ( const GLint * v ) ; + * </pre> + */ + public native void glTexCoord2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord2sv ( const GLshort * v ) ; + * </pre> + */ + public native void glTexCoord2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glTexCoord3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glTexCoord3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3iv ( const GLint * v ) ; + * </pre> + */ + public native void glTexCoord3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord3sv ( const GLshort * v ) ; + * </pre> + */ + public native void glTexCoord3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glTexCoord4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glTexCoord4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4iv ( const GLint * v ) ; + * </pre> + */ + public native void glTexCoord4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexCoord4sv ( const GLshort * v ) ; + * </pre> + */ + public native void glTexCoord4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2d ( GLdouble x , GLdouble y ) ; + * </pre> + */ + public native void glRasterPos2d ( + double x, + double y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2f ( GLfloat x , GLfloat y ) ; + * </pre> + */ + public native void glRasterPos2f ( + float x, + float y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2i ( GLint x , GLint y ) ; + * </pre> + */ + public native void glRasterPos2i ( + int x, + int y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2s ( GLshort x , GLshort y ) ; + * </pre> + */ + public native void glRasterPos2s ( + short x, + short y + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void glRasterPos3d ( + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ; + * </pre> + */ + public native void glRasterPos3f ( + float x, + float y, + float z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ; + * </pre> + */ + public native void glRasterPos3i ( + int x, + int y, + int z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ; + * </pre> + */ + public native void glRasterPos3s ( + short x, + short y, + short z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ; + * </pre> + */ + public native void glRasterPos4d ( + double x, + double y, + double z, + double w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ; + * </pre> + */ + public native void glRasterPos4f ( + float x, + float y, + float z, + float w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ; + * </pre> + */ + public native void glRasterPos4i ( + int x, + int y, + int z, + int w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ; + * </pre> + */ + public native void glRasterPos4s ( + short x, + short y, + short z, + short w + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glRasterPos2dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glRasterPos2fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2iv ( const GLint * v ) ; + * </pre> + */ + public native void glRasterPos2iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos2sv ( const GLshort * v ) ; + * </pre> + */ + public native void glRasterPos2sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glRasterPos3dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glRasterPos3fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3iv ( const GLint * v ) ; + * </pre> + */ + public native void glRasterPos3iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos3sv ( const GLshort * v ) ; + * </pre> + */ + public native void glRasterPos3sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4dv ( const GLdouble * v ) ; + * </pre> + */ + public native void glRasterPos4dv ( + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4fv ( const GLfloat * v ) ; + * </pre> + */ + public native void glRasterPos4fv ( + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4iv ( const GLint * v ) ; + * </pre> + */ + public native void glRasterPos4iv ( + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRasterPos4sv ( const GLshort * v ) ; + * </pre> + */ + public native void glRasterPos4sv ( + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ; + * </pre> + */ + public native void glRectd ( + double x1, + double y1, + double x2, + double y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ; + * </pre> + */ + public native void glRectf ( + float x1, + float y1, + float x2, + float y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ; + * </pre> + */ + public native void glRecti ( + int x1, + int y1, + int x2, + int y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ; + * </pre> + */ + public native void glRects ( + short x1, + short y1, + short x2, + short y2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ; + * </pre> + */ + public native void glRectdv ( + double[] v1, + double[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ; + * </pre> + */ + public native void glRectfv ( + float[] v1, + float[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ; + * </pre> + */ + public native void glRectiv ( + int[] v1, + int[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ; + * </pre> + */ + public native void glRectsv ( + short[] v1, + short[] v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetPointerv ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElement ( GLint i ) ; + * </pre> + */ + public native void glArrayElement ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public native void glDrawArrays ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ; + * </pre> + */ + 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 : + * <pre> + extern void glShadeModel ( GLenum mode ) ; + * </pre> + */ + public native void glShadeModel ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glLightf ( + int light, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLighti ( GLenum light , GLenum pname , GLint param ) ; + * </pre> + */ + public native void glLighti ( + int light, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetLightfv ( + int light, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetLightiv ( + int light, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glLightModelf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeli ( GLenum pname , GLint param ) ; + * </pre> + */ + public native void glLightModeli ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glLightModelfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLightModeliv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glLightModeliv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glMaterialf ( + int face, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ; + * </pre> + */ + public native void glMateriali ( + int face, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetMaterialfv ( + int face, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetMaterialiv ( + int face, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorMaterial ( GLenum face , GLenum mode ) ; + * </pre> + */ + public native void glColorMaterial ( + int face, + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ; + * </pre> + */ + public native void glPixelZoom ( + float xfactor, + float yfactor + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStoref ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glPixelStoref ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelStorei ( GLenum pname , GLint param ) ; + * </pre> + */ + public native void glPixelStorei ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glPixelTransferf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelTransferi ( GLenum pname , GLint param ) ; + * </pre> + */ + public native void glPixelTransferi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ; + * </pre> + */ + public native void glPixelMapfv ( + int map, + int mapsize, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ; + * </pre> + */ + public native void glPixelMapuiv ( + int map, + int mapsize, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ; + * </pre> + */ + public native void glPixelMapusv ( + int map, + int mapsize, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ; + * </pre> + */ + public native void glGetPixelMapfv ( + int map, + float[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ; + * </pre> + */ + public native void glGetPixelMapuiv ( + int map, + int[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ; + * </pre> + */ + public native void glGetPixelMapusv ( + int map, + short[] values + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ; + * </pre> + */ + public native void glBitmap ( + int width, + int height, + float xorig, + float yorig, + float xmove, + float ymove, + byte[] bitmap + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ; + * </pre> + */ + public native void glCopyPixels ( + int x, + int y, + int width, + int height, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ; + * </pre> + */ + public native void glStencilFunc ( + int func, + int ref, + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilMask ( GLuint mask ) ; + * </pre> + */ + public native void glStencilMask ( + int mask + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ; + * </pre> + */ + public native void glStencilOp ( + int fail, + int zfail, + int zpass + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClearStencil ( GLint s ) ; + * </pre> + */ + public native void glClearStencil ( + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ; + * </pre> + */ + public native void glTexGend ( + int coord, + int pname, + double param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glTexGenf ( + int coord, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ; + * </pre> + */ + public native void glTexGeni ( + int coord, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ; + * </pre> + */ + public native void glTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ; + * </pre> + */ + public native void glGetTexGendv ( + int coord, + int pname, + double[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetTexGenfv ( + int coord, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetTexGeniv ( + int coord, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glTexEnvf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public native void glTexEnvi ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetTexEnvfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetTexEnviv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glTexParameterf ( + int target, + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ; + * </pre> + */ + public native void glTexParameteri ( + int target, + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetTexParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetTexParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetTexLevelParameterfv ( + int target, + int level, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetTexLevelParameteriv ( + int target, + int level, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGenTextures ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public native void glGenTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public native void glDeleteTextures ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTexture ( GLenum target , GLuint texture ) ; + * </pre> + */ + public native void glBindTexture ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public native void glPrioritizeTextures ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public native boolean glAreTexturesResident ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTexture ( GLuint texture ) ; + * </pre> + */ + public native boolean glIsTexture ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ; + * </pre> + */ + public native void glCopyTexImage1D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ; + * </pre> + */ + public native void glCopyTexImage2D ( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public native void glCopyTexSubImage1D ( + int target, + int level, + int xoffset, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public native void glCopyTexSubImage2D ( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ; + * </pre> + */ + public native void glMap1d ( + int target, + double u1, + double u2, + int stride, + int order, + double[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ; + * </pre> + */ + public native void glMap1f ( + int target, + float u1, + float u2, + int stride, + int order, + float[] points + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ; + * </pre> + */ + public native void glGetMapdv ( + int target, + int query, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ; + * </pre> + */ + public native void glGetMapfv ( + int target, + int query, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ; + * </pre> + */ + public native void glGetMapiv ( + int target, + int query, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1d ( GLdouble u ) ; + * </pre> + */ + public native void glEvalCoord1d ( + double u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1f ( GLfloat u ) ; + * </pre> + */ + public native void glEvalCoord1f ( + float u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1dv ( const GLdouble * u ) ; + * </pre> + */ + public native void glEvalCoord1dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord1fv ( const GLfloat * u ) ; + * </pre> + */ + public native void glEvalCoord1fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ; + * </pre> + */ + public native void glEvalCoord2d ( + double u, + double v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ; + * </pre> + */ + public native void glEvalCoord2f ( + float u, + float v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2dv ( const GLdouble * u ) ; + * </pre> + */ + public native void glEvalCoord2dv ( + double[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalCoord2fv ( const GLfloat * u ) ; + * </pre> + */ + public native void glEvalCoord2fv ( + float[] u + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ; + * </pre> + */ + public native void glMapGrid1d ( + int un, + double u1, + double u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ; + * </pre> + */ + public native void glMapGrid1f ( + int un, + float u1, + float u2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ; + * </pre> + */ + public native void glMapGrid2d ( + int un, + double u1, + double u2, + int vn, + double v1, + double v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ; + * </pre> + */ + public native void glMapGrid2f ( + int un, + float u1, + float u2, + int vn, + float v1, + float v2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint1 ( GLint i ) ; + * </pre> + */ + public native void glEvalPoint1 ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalPoint2 ( GLint i , GLint j ) ; + * </pre> + */ + public native void glEvalPoint2 ( + int i, + int j + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ; + * </pre> + */ + public native void glEvalMesh1 ( + int mode, + int i1, + int i2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ; + * </pre> + */ + public native void glEvalMesh2 ( + int mode, + int i1, + int i2, + int j1, + int j2 + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogf ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glFogf ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogi ( GLenum pname , GLint param ) ; + * </pre> + */ + public native void glFogi ( + int pname, + int param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogfv ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glFogfv ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFogiv ( GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glFogiv ( + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ; + * </pre> + */ + public native void glFeedbackBuffer ( + int size, + int type, + float[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPassThrough ( GLfloat token ) ; + * </pre> + */ + public native void glPassThrough ( + float token + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ; + * </pre> + */ + public native void glSelectBuffer ( + int size, + int[] buffer + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glInitNames ( void ) ; + * </pre> + */ + public native void glInitNames ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLoadName ( GLuint name ) ; + * </pre> + */ + public native void glLoadName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPushName ( GLuint name ) ; + * </pre> + */ + public native void glPushName ( + int name + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPopName ( void ) ; + * </pre> + */ + public native void glPopName ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public native void glCopyColorSubTable ( + int target, + int start, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public native void glCopyColorTable ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetColorTableParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetColorTableParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquation ( GLenum mode ) ; + * </pre> + */ + public native void glBlendEquation ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public native void glBlendColor ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public native void glHistogram ( + int target, + int width, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetHistogram ( GLenum target ) ; + * </pre> + */ + public native void glResetHistogram ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetHistogramParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetHistogramParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ; + * </pre> + */ + public native void glMinmax ( + int target, + int internalformat, + boolean sink + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glResetMinmax ( GLenum target ) ; + * </pre> + */ + public native void glResetMinmax ( + int target + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetMinmaxParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetMinmaxParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ; + * </pre> + */ + public native void glConvolutionParameterf ( + int target, + int pname, + float params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ; + * </pre> + */ + public native void glConvolutionParameteri ( + int target, + int pname, + int params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ; + * </pre> + */ + public native void glConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ; + * </pre> + */ + public native void glCopyConvolutionFilter1D ( + int target, + int internalformat, + int x, + int y, + int width + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + public native void glCopyConvolutionFilter2D ( + int target, + int internalformat, + int x, + int y, + int width, + int height + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetConvolutionParameterfv ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetConvolutionParameteriv ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ; + * </pre> + */ + 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 : + * <pre> + extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ; + * </pre> + */ + public native void glBlendColorEXT ( + float red, + float green, + float blue, + float alpha + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ; + * </pre> + */ + public native void glPolygonOffsetEXT ( + float factor, + float bias + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ; + * </pre> + */ + public native void glGenTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ; + * </pre> + */ + public native void glDeleteTexturesEXT ( + int n, + int[] textures + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBindTextureEXT ( GLenum target , GLuint texture ) ; + * </pre> + */ + public native void glBindTextureEXT ( + int target, + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ; + * </pre> + */ + public native void glPrioritizeTexturesEXT ( + int n, + int[] textures, + float[] priorities + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ; + * </pre> + */ + public native boolean glAreTexturesResidentEXT ( + int n, + int[] textures, + boolean[] residences + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLboolean glIsTextureEXT ( GLuint texture ) ; + * </pre> + */ + public native boolean glIsTextureEXT ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ; + * </pre> + */ + 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 : + * <pre> + extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ; + * </pre> + */ + public native void glEdgeFlagPointerEXT ( + int stride, + int count, + boolean[] ptr + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetPointervEXT ( GLenum pname , void * * params ) ; + * </pre> + */ + 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 : + * <pre> + extern void glArrayElementEXT ( GLint i ) ; + * </pre> + */ + public native void glArrayElementEXT ( + int i + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ; + * </pre> + */ + public native void glDrawArraysEXT ( + int mode, + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glBlendEquationEXT ( GLenum mode ) ; + * </pre> + */ + public native void glBlendEquationEXT ( + int mode + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ; + * </pre> + */ + public native void glPointParameterfEXT ( + int pname, + float param + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ; + * </pre> + */ + public native void glPointParameterfvEXT ( + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ; + * </pre> + */ + 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 : + * <pre> + extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ; + * </pre> + */ + public native void glGetColorTableParameterfvEXT ( + int target, + int pname, + float[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ; + * </pre> + */ + public native void glGetColorTableParameterivEXT ( + int target, + int pname, + int[] params + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glLockArraysEXT ( GLint first , GLsizei count ) ; + * </pre> + */ + public native void glLockArraysEXT ( + int first, + int count + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glUnlockArraysEXT ( void ) ; + * </pre> + */ + public native void glUnlockArraysEXT ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public native void glActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glClientActiveTextureARB ( GLenum texture ) ; + * </pre> + */ + public native void glClientActiveTextureARB ( + int texture + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ; + * </pre> + */ + public native void glMultiTexCoord1dARB ( + int target, + double s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public native void glMultiTexCoord1dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ; + * </pre> + */ + public native void glMultiTexCoord1fARB ( + int target, + float s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public native void glMultiTexCoord1fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ; + * </pre> + */ + public native void glMultiTexCoord1iARB ( + int target, + int s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public native void glMultiTexCoord1ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ; + * </pre> + */ + public native void glMultiTexCoord1sARB ( + int target, + short s + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public native void glMultiTexCoord1svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ; + * </pre> + */ + public native void glMultiTexCoord2dARB ( + int target, + double s, + double t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public native void glMultiTexCoord2dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ; + * </pre> + */ + public native void glMultiTexCoord2fARB ( + int target, + float s, + float t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public native void glMultiTexCoord2fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ; + * </pre> + */ + public native void glMultiTexCoord2iARB ( + int target, + int s, + int t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public native void glMultiTexCoord2ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ; + * </pre> + */ + public native void glMultiTexCoord2sARB ( + int target, + short s, + short t + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public native void glMultiTexCoord2svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ; + * </pre> + */ + public native void glMultiTexCoord3dARB ( + int target, + double s, + double t, + double r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public native void glMultiTexCoord3dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ; + * </pre> + */ + public native void glMultiTexCoord3fARB ( + int target, + float s, + float t, + float r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public native void glMultiTexCoord3fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ; + * </pre> + */ + public native void glMultiTexCoord3iARB ( + int target, + int s, + int t, + int r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public native void glMultiTexCoord3ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ; + * </pre> + */ + public native void glMultiTexCoord3sARB ( + int target, + short s, + short t, + short r + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + public native void glMultiTexCoord3svARB ( + int target, + short[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ; + * </pre> + */ + public native void glMultiTexCoord4dARB ( + int target, + double s, + double t, + double r, + double q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ; + * </pre> + */ + public native void glMultiTexCoord4dvARB ( + int target, + double[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ; + * </pre> + */ + public native void glMultiTexCoord4fARB ( + int target, + float s, + float t, + float r, + float q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ; + * </pre> + */ + public native void glMultiTexCoord4fvARB ( + int target, + float[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ; + * </pre> + */ + public native void glMultiTexCoord4iARB ( + int target, + int s, + int t, + int r, + int q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ; + * </pre> + */ + public native void glMultiTexCoord4ivARB ( + int target, + int[] v + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ; + * </pre> + */ + public native void glMultiTexCoord4sARB ( + int target, + short s, + short t, + short r, + short q + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ; + * </pre> + */ + public void gluLookAt ( + double eyex, + double eyey, + double eyez, + double centerx, + double centery, + double centerz, + double upx, + double upy, + double upz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ; + * </pre> + */ + public void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ; + * </pre> + */ + public void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ; + * </pre> + */ + public void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + public int gluProject ( + double objx, + double objy, + double objz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] winx, + double[] winy, + double[] winz + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + public int gluUnProject ( + double winx, + double winy, + double winz, + double[] modelMatrix, + double[] projMatrix, + int[] viewport, + double[] objx, + double[] objy, + double[] objz + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ; + * </pre> + */ + public int gluScaleImage ( + int format, + int widthin, + int heightin, + int typein, + byte[] datain, + int widthout, + int heightout, + int typeout, + byte[] dataout + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLUquadricObj * gluNewQuadric ( void ) ; + * </pre> + */ + public int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ; + * </pre> + */ + public void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ; + * </pre> + */ + public void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ; + * </pre> + */ + public void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ; + * </pre> + */ + public void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ; + * </pre> + */ + public void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ; + * </pre> + */ + public void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ; + * </pre> + */ + public void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ; + * </pre> + */ + public void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ; + * </pre> + */ + public int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ; + * </pre> + */ + public void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ; + * </pre> + */ + public void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ; + * </pre> + */ + public void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ; + * </pre> + */ + public void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluBeginTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ; + * </pre> + */ + public void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUtesselator * gluNewTess ( void ) ; + * </pre> + */ + public int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessBeginContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessEndContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ; + * </pre> + */ + public void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ; + * </pre> + */ + public void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ; + * </pre> + */ + public void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + 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 <classname>" 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 <classname>" 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 <classname>" 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 : + * <pre> + extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ; + * </pre> + */ + public final native void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ; + * </pre> + */ + public final native void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ; + * </pre> + */ + public final native void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLUquadricObj * gluNewQuadric ( void ) ; + * </pre> + */ + public final native int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ; + * </pre> + */ + public final native void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ; + * </pre> + */ + public final native void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ; + * </pre> + */ + public final native void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ; + * </pre> + */ + public final native void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ; + * </pre> + */ + public final native void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ; + * </pre> + */ + public final native void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ; + * </pre> + */ + public final native void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ; + * </pre> + */ + public final native void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ; + * </pre> + */ + public final native int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ; + * </pre> + */ + public final native void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ; + * </pre> + */ + public final native void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ; + * </pre> + */ + public final native void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ; + * </pre> + */ + public final native void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluBeginTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public final native void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ; + * </pre> + */ + public final native void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUtesselator * gluNewTess ( void ) ; + * </pre> + */ + public final native int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessBeginContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public final native void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessEndContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public final native void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public final native void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ; + * </pre> + */ + public final native void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public final native void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ; + * </pre> + */ + public final native void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public final native void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ; + * </pre> + */ + public final native void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + 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 <classname>" 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 <classname>" 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 <classname>" 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 : + * <pre> + extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ; + * </pre> + */ + public native void gluOrtho2D ( + double left, + double right, + double bottom, + double top + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ; + * </pre> + */ + public native void gluPerspective ( + double fovy, + double aspect, + double zNear, + double zFar + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ; + * </pre> + */ + public native void gluPickMatrix ( + double x, + double y, + double width, + double height, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ; + * </pre> + */ + 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 : + * <pre> + extern GLUquadricObj * gluNewQuadric ( void ) ; + * </pre> + */ + public native int gluNewQuadric ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ; + * </pre> + */ + public native void gluQuadricDrawStyle ( + int quadObject, + int drawStyle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ; + * </pre> + */ + public native void gluQuadricOrientation ( + int quadObject, + int orientation + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ; + * </pre> + */ + public native void gluQuadricNormals ( + int quadObject, + int normals + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ; + * </pre> + */ + public native void gluQuadricTexture ( + int quadObject, + boolean textureCoords + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ; + * </pre> + */ + public native void gluCylinder ( + int qobj, + double baseRadius, + double topRadius, + double height, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ; + * </pre> + */ + public native void gluSphere ( + int qobj, + double radius, + int slices, + int stacks + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ; + * </pre> + */ + public native void gluDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ; + * </pre> + */ + public native void gluPartialDisk ( + int qobj, + double innerRadius, + double outerRadius, + int slices, + int loops, + double startAngle, + double sweepAngle + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ; + * </pre> + */ + public native int gluNewNurbsRenderer ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ; + * </pre> + */ + public native void gluLoadSamplingMatrices ( + int nobj, + float[] modelMatrix, + float[] projMatrix, + int[] viewport + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ; + * </pre> + */ + public native void gluNurbsProperty ( + int nobj, + int property, + float value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ; + * </pre> + */ + public native void gluGetNurbsProperty ( + int nobj, + int property, + float[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluBeginCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndCurve ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluEndCurve ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ; + * </pre> + */ + public native void gluNurbsCurve ( + int nobj, + int nknots, + float[] knot, + int stride, + float[] ctlarray, + int order, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluBeginSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndSurface ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluEndSurface ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + 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 ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluBeginTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluBeginTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndTrim ( GLUnurbsObj * nobj ) ; + * </pre> + */ + public native void gluEndTrim ( + int nobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ; + * </pre> + */ + public native void gluPwlCurve ( + int nobj, + int count, + float[] array, + int stride, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern GLUtesselator * gluNewTess ( void ) ; + * </pre> + */ + public native int gluNewTess ( + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessBeginContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public native void gluTessBeginContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ; + * </pre> + */ + 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 : + * <pre> + extern void gluTessEndContour ( GLUtesselator * tobj ) ; + * </pre> + */ + public native void gluTessEndContour ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public native void gluTessEndPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ; + * </pre> + */ + public native void gluTessProperty ( + int tobj, + int which, + double value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ; + * </pre> + */ + public native void gluTessNormal ( + int tobj, + double x, + double y, + double z + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ; + * </pre> + */ + public native void gluGetTessProperty ( + int tobj, + int which, + double[] value + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluBeginPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + public native void gluBeginPolygon ( + int tobj + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ; + * </pre> + */ + public native void gluNextContour ( + int tobj, + int type + ) ; + +/** + * Original Function-Prototype : + * <pre> + extern void gluEndPolygon ( GLUtesselator * tobj ) ; + * </pre> + */ + 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 ! + * + * <p> + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * 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: + * + * <pre> + <a href="GLAnimCanvas.html#setUseRepaint(boolean)">setUseRepaint(false)</a> + * </pre> + * <p> + * + * 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: + * + * <pre> + <a href="GLAnimCanvas.html#setUseFpsSleep(boolean)">setUseFpsSleep(false)</a> + * </pre> + * <p> + * 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: + * + * <pre> + <p> + A JVM with operating system threads has: <b>native-threads</b> + <p> + A JVM where all JVM threads runs in one operating-system-thread + has: <b>green-threads</b> + + <a name="table"> + <table border> + <tr> + <th><th>green-threads<th>native-threads + <tr> + <td align=center><a href="GLAnimCanvas.html#setUseRepaint(boolean)"><code>setUseRepaint</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + <tr> + <td align=center><a href="GLAnimCanvas.html#setUseFpsSleep(boolean)"><code>setUseFpsSleep</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + + </table> + </a> + * </pre> + * + * 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) + * + * <p> + * To use real fps settings, the following functions provides you to do so: + * <pre> + <a href="GLAnimCanvas.html#setAnimateFps(double, int)">setAnimateFps</a> + <a href="GLAnimCanvas.html#getMaxFps()">getMaxFps</a> + * </pre> + * Like the first animation run, this class renders a view frames (default 10) + * to subtract the render time from the sleep time ! + * <p> + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLAnimCanvas.html#init()">init - 1st initialisation</a> + <a href="GLAnimCanvas.html#display()">display - render one frame</a> + <a href="GLCanvas.html#reshape(int, int)">reshape - to reshape (window resize)</a> + <a href="GLAnimCanvas.html#ReInit()">ReInit - ReInitialisation after stop for setSuspended(false)</a> + * </pre> + * + * @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 ! + * + * <p> + * + * You should set shallWeRender here, + * to signalize the animation-loop 'run' to supsend + * <p> + * 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. + * <p> + * 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 ! + * <p> + * + * @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 ! + * <p> + * + * @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 + * <p> + * 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 + * <p> + * 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 + * <p> + * this function is called automatically by + * run, if the thread is suspended via shallWeRender + * <p> + * 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 ! + * <p> + * 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 + * <p> + * 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 + * <p> + * 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 + * <p> + * 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 ! + * + * <p> + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLCanvas.html#init()">preInit - initialisation before creating GLContext</a> + <a href="GLCanvas.html#init()">init - 1st initialisation after creating GLContext</a> + <a href="GLCanvas.html#doCleanup()">doCleanup - OGL cleanup prior to context deletion</a> + <a href="GLCanvas.html#display()">display - render your frame</a> + <a href="GLCanvas.html#reshape(int, int)">reshape - to reshape (window resize), gljResize() is allready invoked !</a> + * </pre> + * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * <pre> + <a href="GLCanvas.html#cvsIsInit()">cvsIsInit</a> + * </pre> + * <p> + * IF you remove/release a GLCanvas, + * e.g. you want to close/dispose it�s Window (which contains this GLCanvas), + * you HAVE TO call: + * + * <pre> + <a href="GLCanvas.html#cvsDispose()">cvsDispose</a> + * </pre> + * 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 ! + * + * <p> + * We do override the following Canvas methods. + * + * <pre> + <a href="GLCanvas.html#update(java.awt.Graphics)">update</a> + <a href="GLCanvas.html#paint(java.awt.Graphics)">paint</a> + * </pre> + * <p> + * + * @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<rh) + { + h = (int) ((rw / iaspect)+0.5); + } else { + w = (int) ((rh * iaspect)+0.5); + } + } else { + w = txtLoader.getImageWidth(); + h = txtLoader.getImageHeight(); + } + if(rw!=w || rh!=h) + { + internalSetSize( w, h ); + return ; /* the true resize is coming up ... */ + } + } + reshape_resize_sema=1; + gl.glViewport (0, 0, w, h); + SetCamera(); + } + + + protected void DrawObj(boolean blend) + { + gl.glPushMatrix(); + if(blend) + { + gl.glEnable(GL_BLEND); + gl.glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); + } + + gl.glColor4f(1f,1f,1f,1f); + + if(txtLoader!=null && txtLoader.isOk()) + { + gl.glEnable(GL_TEXTURE_2D); + gl.glBegin(GL_QUADS); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(0f,0f); + gl.glVertex2f(0f, 0f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(0f,1f); + gl.glVertex2f(0f, 1f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(1f,1f); + gl.glVertex2f(1f, 1f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(1f,0f); + gl.glVertex2f(1f, 0f); + + gl.glEnd(); + gl.glDisable(GL_TEXTURE_2D); + } + + if(blend) + gl.glDisable(GL_BLEND); + + gl.glPopMatrix(); + } + + protected void SetCamera() + { + float imgwidth = 1f; + float imgheight = 1f; + float txtdx=0f; + float txtdy=0f; + + if(txtLoader!=null && txtLoader.isOk()) + { + Dimension idim = new Dimension(txtLoader.getImageWidth(), + txtLoader.getImageHeight()); + Dimension tdim = new Dimension(txtLoader.getTextureWidth(), + txtLoader.getTextureHeight()); + + imgwidth = (float)idim.width/(float)tdim.width; + imgheight = (float)idim.height/(float)tdim.height; + + /* + System.out.println("image : "+idim); + System.out.println("text : "+tdim); + System.out.println("image/text : "+imgwidth+"/"+imgheight); + */ + } + + gl.glMatrixMode (GL_PROJECTION); + gl.glLoadIdentity (); + glu.gluOrtho2D(0, imgwidth, + 0, imgheight); + + gl.glMatrixMode (GL_MODELVIEW); + gl.glLoadIdentity (); + } + +} + diff --git a/gl4java/jau/awt/WinHandleAccess.java b/gl4java/jau/awt/WinHandleAccess.java new file mode 100644 index 0000000..b6e8c87 --- /dev/null +++ b/gl4java/jau/awt/WinHandleAccess.java @@ -0,0 +1,21 @@ +/**
+ * @(#) WinHandleAccess.java
+ */
+package gl4java.jau.awt;
+
+import java.awt.Component;
+import java.awt.Graphics;
+
+/**
+ * The base interface for accessing the native window handle
+ *
+ * @version 2.00, 21. April 1999
+ * @author Sven Goethel
+ */
+public interface WinHandleAccess
+{
+ public abstract int getWinHandle(Component component, Graphics g);
+
+ public abstract int getWinDepth(Component component, Graphics g);
+
+}
diff --git a/gl4java/jau/awt/macintosh/MacHandleAccess.java b/gl4java/jau/awt/macintosh/MacHandleAccess.java new file mode 100644 index 0000000..db1c3ef --- /dev/null +++ b/gl4java/jau/awt/macintosh/MacHandleAccess.java @@ -0,0 +1,89 @@ +/* + * @(#) MacHandleAccess.java + */ + +package gl4java.jau.awt.macintosh; + +import sun.awt.DrawingSurface; +import sun.awt.DrawingSurfaceInfo; +import sun.awt.MacDrawingSurface; + +import java.awt.*; + +/** + * This class has no user servicable parts inside. It is + * used internally by GLFrame and by our package spoofed + * sun.awt classes that give us internal access to window + * variables that we need to set up the OpenGL drawing + * context + * + * + * @see WinHandleAccess + * @version 0.1, 7. JULY 1998 + * @author Sven Goethel + * @author ported to Mac by gerard ziemski + * + */ +public class MacHandleAccess implements gl4java.jau.awt.WinHandleAccess +{ + protected DrawingSurface ds; + protected DrawingSurfaceInfo dsi; + protected MacDrawingSurface mds; + protected int window, + depth; + + + protected void achieveData(java.awt.Component c, java.awt.Graphics g) + { + /* outta java3d */ + dsi = null; + mds = null; + window = 0; + depth = 0; + + ds = ((DrawingSurface)c.getPeer()); + dsi = ds.getDrawingSurfaceInfo(); + + if (dsi != null) + { + dsi.lock(); + mds = (MacDrawingSurface)dsi.getSurface(); + dsi.unlock(); + } + + if (mds != null) + { + dsi.lock(); + + window = mds.getPort(); + depth = c.getColorModel().getPixelSize(); + + dsi.unlock(); + } + + if (mds == null) + { + System.out.println("MacHandleAccess:getWinHandle failed"); + } + } + +/** + * + * gets some structure for windows, and drawable on Mac + */ + public int getWinHandle(java.awt.Component c, java.awt.Graphics g) + { + achieveData(c, g); + return window; + } + +/** + * + * gets some structure for windows, and drawable on Mac + */ + public int getWinDepth(java.awt.Component c, java.awt.Graphics g) + { + achieveData(c, g); + return depth; + } +} diff --git a/gl4java/jau/awt/motif/X11HandleAccess.java b/gl4java/jau/awt/motif/X11HandleAccess.java new file mode 100644 index 0000000..f07e111 --- /dev/null +++ b/gl4java/jau/awt/motif/X11HandleAccess.java @@ -0,0 +1,86 @@ +/*
+ * @(#) X11HandleAccess.java
+ */
+
+package gl4java.jau.awt.motif;
+
+import sun.awt.X11DrawingSurface;
+import sun.awt.DrawingSurface;
+import sun.awt.DrawingSurfaceInfo;
+
+/**
+ * The unix-x11 implementation for accessing the native window handle
+ *
+ * This class has no user servicable parts inside. It is
+ * used internally by GLFrame and by our package spoofed
+ * sun.awt classes that give us internal access to window
+ * variables that we need to set up the OpenGL drawing
+ * ontext
+ *
+ * @see WinHandleAccess
+ * @version 0.1, 7. JULY 1998
+ * @author Sven Goethel
+ *
+ */
+public class X11HandleAccess
+ implements gl4java.jau.awt.WinHandleAccess
+{
+ protected DrawingSurfaceInfo dsi;
+ protected X11DrawingSurface wds;
+ protected int window, depth;
+
+ protected void achieveData(java.awt.Component c, java.awt.Graphics g)
+ {
+ /* outta java3d */
+ dsi=null;
+ wds=null;
+ window=0; depth=0;
+
+ dsi = ((DrawingSurface)(c.getPeer())).getDrawingSurfaceInfo();
+ if(dsi!=null)
+ {
+ dsi.lock();
+ wds = (X11DrawingSurface)dsi.getSurface();
+ dsi.unlock();
+ }
+ if(wds!=null)
+ {
+ dsi.lock();
+ window = wds.getDrawable();
+ depth = wds.getDepth();
+
+ /*
+ System.out.println("wds.Depth ="+wds.getDepth());
+ System.out.println("wds.VisualID ="+wds.getVisualID());
+ System.out.println("wds.Display ="+wds.getDisplay());
+ System.out.println("wds.window ="+window);
+ System.out.println("");
+ */
+
+ dsi.unlock();
+ }
+ if(wds==null)
+ System.out.println("X11HandleAccess.getWinHandle failed, because the given Component is NOT a Motif-Component\n");
+ }
+
+/**
+ *
+ * gets some structure for windows, and drawable on X11
+ */
+ public int getWinHandle(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return window;
+ }
+
+/**
+ *
+ * gets some structure for windows, and drawable on X11
+ */
+ public int getWinDepth(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return depth;
+ }
+}
+
diff --git a/gl4java/jau/awt/windows/MSWin32HandleAccess.java b/gl4java/jau/awt/windows/MSWin32HandleAccess.java new file mode 100644 index 0000000..1dd4d93 --- /dev/null +++ b/gl4java/jau/awt/windows/MSWin32HandleAccess.java @@ -0,0 +1,60 @@ +/*
+ * @(#) MSWin32HandleAccess.java
+ */
+
+package gl4java.jau.awt.windows;
+
+import java.awt.Component;
+import com.ms.awt.GraphicsX;
+
+/**
+ * The ms-windows implementation for accessing the native window handle
+ *
+ * This class has no user servicable parts inside. It is
+ * used internally by GLFrame and by our package spoofed
+ * sun.awt classes that give us internal access to window
+ * variables that we need to set up the OpenGL drawing
+ * ontext
+ *
+ * @see WinHandleAccess
+ * @version 0.1, 3. JULY 1999
+ * @author Ron Cemer
+ *
+ */
+public class MSWin32HandleAccess
+ implements gl4java.jau.awt.WinHandleAccess
+{
+ protected int window, depth;
+
+ /**
+ * @dll.import("USER32",auto)
+ */
+ private static native int WindowFromDC(int hdc);
+
+ protected void achieveData(java.awt.Component c, java.awt.Graphics g)
+ {
+ window = WindowFromDC(((GraphicsX)g).gdc.pGetDC());
+ depth = c.getColorModel().getPixelSize();
+ }
+
+ /**
+ *
+ * get the window handle
+ */
+ public int getWinHandle(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return window;
+ }
+
+ /**
+ *
+ * get the color depth
+ */
+ public int getWinDepth(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return depth;
+ }
+}
+
diff --git a/gl4java/jau/awt/windows/Win32HandleAccess.java b/gl4java/jau/awt/windows/Win32HandleAccess.java new file mode 100644 index 0000000..38b5c93 --- /dev/null +++ b/gl4java/jau/awt/windows/Win32HandleAccess.java @@ -0,0 +1,84 @@ +/*
+ * @(#) Win32HandleAccess.java
+ */
+
+package gl4java.jau.awt.windows;
+
+import sun.awt.DrawingSurface;
+import sun.awt.Win32DrawingSurface;
+import sun.awt.DrawingSurfaceInfo;
+
+/**
+ * The ms-windows implementation for accessing the native window handle
+ *
+ * This class has no user servicable parts inside. It is
+ * used internally by GLFrame and by our package spoofed
+ * sun.awt classes that give us internal access to window
+ * variables that we need to set up the OpenGL drawing
+ * ontext
+ *
+ * @see WinHandleAccess
+ * @version 0.1, 7. JULY 1998
+ * @author Sven Goethel
+ *
+ */
+public class Win32HandleAccess
+ implements gl4java.jau.awt.WinHandleAccess
+{
+
+ protected DrawingSurfaceInfo dsi;
+ protected Win32DrawingSurface wds;
+ protected int window, depth;
+
+ protected void achieveData(java.awt.Component c, java.awt.Graphics g)
+ {
+ /* outta java3d */
+ dsi=null;
+ wds=null;
+ window=0; depth=0;
+
+ dsi = ((DrawingSurface)(c.getPeer())).getDrawingSurfaceInfo();
+ if(dsi!=null)
+ {
+ dsi.lock();
+ wds = (Win32DrawingSurface)dsi.getSurface();
+ dsi.unlock();
+ }
+ if(wds!=null)
+ {
+ dsi.lock();
+ window = wds.getHDC();
+ depth = wds.getDepth();
+ /*
+ System.out.println("wds ="+wds);
+ System.out.println("wds.Depth ="+wds.getDepth());
+ System.out.println("wds.HDC ="+wds.getHDC());
+ System.out.println("wds.HWnd ="+wds.getHWnd());
+ */
+ dsi.unlock();
+ }
+ if(wds==null)
+ System.out.println("Win32HandleAccess.getWinHandle failed, because the given Component is NOT a Window-Component\n");
+ }
+
+/**
+ *
+ * gets some structure for windows, and drawable on Win32
+ */
+ public int getWinHandle(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return window;
+ }
+
+/**
+ *
+ * gets some structure for windows, and drawable on Win32
+ */
+ public int getWinDepth(java.awt.Component c, java.awt.Graphics g)
+ {
+ achieveData(c, g);
+ return depth;
+ }
+}
+
diff --git a/gl4java/swing/GLAnimJPanel.java b/gl4java/swing/GLAnimJPanel.java new file mode 100644 index 0000000..e9bdbdf --- /dev/null +++ b/gl4java/swing/GLAnimJPanel.java @@ -0,0 +1,720 @@ +/** + * @(#) GLAnimJPanel.java + */ + +package gl4java.swing; + +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 ! + * + * <p> + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * 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: + * + * <pre> + <a href="GLAnimJPanel.html#setUseRepaint(boolean)">setUseRepaint(false)</a> + * </pre> + * <p> + * + * 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: + * + * <pre> + <a href="GLAnimJPanel.html#setUseFpsSleep(boolean)">setUseFpsSleep(false)</a> + * </pre> + * <p> + * 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: + * + * <pre> + <p> + A JVM with operating system threads has: <b>native-threads</b> + <p> + A JVM where all JVM threads runs in one operating-system-thread + has: <b>green-threads</b> + + <a name="table"> + <table border> + <tr> + <th><th>green-threads<th>native-threads + <tr> + <td align=center><a href="GLAnimJPanel.html#setUseRepaint(boolean)"><code>setUseRepaint</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + <tr> + <td align=center><a href="GLAnimJPanel.html#setUseFpsSleep(boolean)"><code>setUseFpsSleep</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + + </table> + </a> + * </pre> + * + * 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) + * + * <p> + * To use real fps settings, the following functions provides you to do so: + * <pre> + <a href="GLAnimJPanel.html#setAnimateFps(double, int)">setAnimateFps</a> + <a href="GLAnimJPanel.html#getMaxFps()">getMaxFps</a> + * </pre> + * Like the first animation run, this class renders a view frames (default 10) + * to subtract the render time from the sleep time ! + * <p> + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLAnimJPanel.html#init()">init - 1st initialisation</a> + <a href="GLAnimJPanel.html#display()">display - render one frame</a> + <a href="GLCanvas.html#reshape(int, int)">reshape - to reshape (window resize)</a> + <a href="GLAnimJPanel.html#ReInit()">ReInit - ReInitialisation after stop for setSuspended(false)</a> + * </pre> + * + * @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 ! + * + * <p> + * + * You should set shallWeRender here, + * to signalize the animation-loop 'run' to supsend + * <p> + * 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. + * <p> + * 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 ! + * <p> + * + * @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 ! + * <p> + * + * @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 + * <p> + * 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 + * <p> + * 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 + * <p> + * this function is called automatically by + * run, if the thread is suspended via shallWeRender + * <p> + * 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 ! + * <p> + * 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 + * <p> + * 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 + * <p> + * 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 + * <p> + * 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 ! + * + * <p> + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLJPanel.html#init()">preInit - initialisation before creating GLContext</a> + <a href="GLJPanel.html#init()">init - 1st initialisation after creating GLContext</a> + <a href="GLJPanel.html#doCleanup()">doCleanup - OGL cleanup prior to context deletion</a> + <a href="GLJPanel.html#display()">display - render your frame</a> + <a href="GLJPanel.html#reshape(int, int)">reshape - to reshape (window resize), gljResize() is allready invoked !</a> + * </pre> + * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * <pre> + <a href="GLJPanel.html#cvsIsInit()">cvsIsInit</a> + * </pre> + * <p> + * IF you remove/release a GLJPanel, + * e.g. you want to close/dispose it�s Window (which contains this GLJPanel), + * you HAVE TO call: + * + * <pre> + <a href="GLJPanel.html#cvsDispose()">cvsDispose</a> + * </pre> + * 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 ! + * + * <p> + * We do override the following Canvas methods. + * + * <pre> + <a href="GLJPanel.html#update(java.awt.Graphics)">update</a> + <a href="GLJPanel.html#paint(java.awt.Graphics)">paint</a> + * </pre> + * <p> + * + * @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 ! + * + * <p> + * + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLJPanel.html#init()">preInit - initialisation before creating GLContext</a> + <a href="GLJPanel.html#init()">init - 1st initialisation after creating GLContext</a> + <a href="GLJPanel.html#doCleanup()">doCleanup - OGL cleanup prior to context deletion</a> + <a href="GLJPanel.html#display()">display - render your frame</a> + <a href="GLJPanel.html#reshape(int, int)">reshape - to reshape (window resize), gljResize() is allready invoked !</a> + * </pre> + * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * <pre> + <a href="GLJPanel.html#cvsIsInit()">cvsIsInit</a> + * </pre> + * <p> + * IF you remove/release a GLJPanel, + * e.g. you want to close/dispose it�s Window (which contains this GLJPanel), + * you HAVE TO call: + * + * <pre> + <a href="GLJPanel.html#cvsDispose()">cvsDispose</a> + * </pre> + * 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 ! + * + * <p> + * We do override the following Canvas methods. + * + * <pre> + <a href="GLJPanel.html#update(java.awt.Graphics)">update</a> + <a href="GLJPanel.html#paint(java.awt.Graphics)">paint</a> + * </pre> + * <p> + * + * @@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 <glj-libname> gl4java-glj-lib native library + * -gllib <gl-libname> gl4java-gl-lib native library + * -glulib <glu-libname> gl4java-glu-lib native library + * -glclass <gl-class> gl4java-gl-class java GLFunc implementation + * -gluclass <glu-class> gl4java-glu-class java GLUFunc implementation + * -testclass <GLCanvas or SimpleGLAnimApplet1 Implementation Class> A derivation of GLCanvas (GLAnimCanvas also) or SimpleGLAnimApplet1 can be started here for testing purposes ! + * -w <int> the testclass window width (default 400) + * -h <int> 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 <options>, where options can be: "); + System.out.println(" -gljlib <glj-libname> \t\t\t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib <gl-libname> \t\t\t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib <glu-libname> \t\t\t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass <gl-class> \t\t\t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass <glu-class> \t\t\t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)"); + System.out.println(" -testclass <GLCanvas Implementation Class> \t\t\t a derivation of GLCanvas (GLCanvas or GLAnimCanvas) can be started here for testing purposes !"); + System.out.println(" -w <int> \t\t\t the testclass window width (default 800) !"); + System.out.println(" -h <int> \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<s.length(); i++)
+ {
+ character = bytes[i];
+ if (character < fontinfo.first ||
+ character >= 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<s.length(); i++)
+ {
+ c = bytes[i];
+ if (c < 0 || c >= 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<string.length(); i++) {
+ c = bytestring[i];
+ if ((c >= 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<string.length(); i++) {
+ c = bytestring[i];
+ if (c >= 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 <MonoRoman.stroke >data/glutStrokeMonoRoman.java + +data/glutStrokeRoman.java: strokegen + ./strokegen -s glutStrokeRoman <Roman.stroke >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 <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <GL/gl.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> + +#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 <X11/Xos.h> +#include <stdio.h> +#include <ctype.h> +#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 <dval> REAL +%token <ival> INTEGER +%token <cval> STRING + +%token <nil> BOTTOM +%token <nil> CENTER +%token <nil> CLOSE +%token <nil> FONTNAME +%token <nil> PROPERTIES +%token <nil> NUM_CH +%token <nil> INDEX +%token <nil> L_SPACE +%token <nil> MAGIC +%token <nil> OPEN +%token <nil> RIGHT +%token <nil> R_SPACE +%token <nil> STROKE +%token <nil> TOP +%token <nil> VERTICES +%token <nil> BEARING +%token <nil> WIDTH + +%type <cval> fontname +%type <ival> properties +%type <dval> top bottom center right +%type <ival> nstroke nvertice n_pts index num_ch +%type <ival> closeflag +%type <ival> counter +%type <dval> 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; + k<spath->n_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 <stdlib.h>
+#include <ctype.h>
+#include <math.h>
+#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<imageWidth;x++)
+ {
+ aPixel = iPixels[y_desc*imageWidth + x];
+
+ // red
+ pixel[offset++]=
+ new Integer( (aPixel >> 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<imageWidth;x++) + { + aPixel = iPixels[y*imageWidth + x]; + + switch (glFormat) + { + case GL_RGBA: + pixel[offset] = (byte)(aPixel>>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 <os> 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<imageWidth*imageHeight*3; i+=3) + { + tmp=pixel[i]; + pixel[i]=pixel[i+2]; + pixel[i+2]=tmp; + } + + reader.close(); + setTextureSize(); + return true; + + } catch (Exception ex) { + System.out.println("An exception occured, while loading a TGATexture"); + System.out.println(ex); + error=true; + } + return false; + } +} + diff --git a/gl4java/utils/textures/TextureGrabber.java b/gl4java/utils/textures/TextureGrabber.java new file mode 100644 index 0000000..d7d3bff --- /dev/null +++ b/gl4java/utils/textures/TextureGrabber.java @@ -0,0 +1,116 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.io.*; +import java.net.*; + +/** + * This abstract Class defines the interface + * for ALL texture Grabbers ! + * The TextureGrabber's implementations are used to + * save the pixels of the GL Context to a file ! + * + * @see TextureTool + * @see GLImageCanvas + */ +public abstract class TextureGrabber +implements GLEnum, GLUEnum +{ + protected byte[] pixels=null; + protected int xpos; + protected int ypos; + protected int width; + protected int height; + protected GLFunc gl; + + public TextureGrabber(GLFunc gl) + { + this.gl=gl; + } + + /** + * Grab the pixels outta the OpenGL Frambuffer + * + * @param source the frambuffer source (like glReadBuffer), + * can be: GL_FRONT, GL_BACK, .... + * @param x the xpos + * @param y the ypos + * @param w the width + * @param h the height + * + * @see GLFunc#glReadBuffer + */ + public void grabPixels(int source, int x, int y, int w, int h) + { + int swapbytes[]={0}, lsbfirst[]={0}, rowlength[]={0}; + int skiprows[]={0}, skippixels[]={0}, alignment[]={0}; + + xpos=x; + ypos=y; + width=w; + height=h; + pixels=new byte[w * h * 3]; + + /* 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); + + /* Little endian machines (DEC Alpha, Intel 80x86, ... for example) could + benefit from setting GL_PACK_LSB_FIRST to GL_TRUE + instead of GL_FALSE, but this would require changing the + generated bitmaps too. */ + gl.glPixelStorei(GL_PACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_PACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, w); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + + //get viewport data + gl.glReadBuffer(source); + gl.glReadPixels(x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, pixels); + + 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]); + + } + + public boolean write2File(String fname) + { + try { + OutputStream os= new java.io.FileOutputStream(fname); + return write2File(os); + } catch (Exception ex) { + System.out.println("TGATextureGrabber.write2File <"+ + fname+"> 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<imageWidth) + { textWidth*=2; e_x++; } + + e_y=0; textHeight=1; + while (textHeight<imageHeight) + { textHeight*=2; e_y++; } + + int[] format = new int[1]; + + do { + gl.glTexImage2D(GL_PROXY_TEXTURE_2D, 0, + getComponents(), + textWidth, textHeight, + 0, + glFormat, + GL_UNSIGNED_BYTE, + (byte[])null); + glutReportErrors(); + + gl.glGetTexLevelParameteriv + (GL_PROXY_TEXTURE_2D, 0, + GL_TEXTURE_INTERNAL_FORMAT, format); + glutReportErrors(); + + + // + // if(format[0]!=glFormat) + // + if(format[0]==0) + { + System.out.println("text size too big: "+this.toString()+", "+format[0]+"!="+glFormat); + if(textWidth>textHeight) + { + e_x--; textWidth=1; + for(i=e_x; i>0; i--) + textWidth*=2; + } else { + e_y--; textHeight=1; + for(i=e_y; i>0; i--) + textHeight*=2; + } + } + } while (format[0]==0 && /* format[0]!=glFormat && */ + textWidth>1 && textHeight>1); + + } + + /** + * The image data, with the given + * Dimension and Format ! + */ + public final byte[] getTexture() { return pixel; } + + /** + * This method can be called, + * if you want to have a normal image-data size + * with the power of two ! + * + * The Ascpect-Ratio is dropped ! + * + * You can call this method directly after loading a + * texture ! + * + * The pixel store mode GL_UNPACK_ALIGNMENT & GL_PACK_ALIGNMENT, + * is set temporary to byte alignment, then back to default (4) ! + * + * The pixel store mode GL_UNPACK_ROW_LENGTH & GL_PACK_ROW_LENGTH, + * is set temporary to imageWidth, then back to default (0) ! + * + * @see GLUFunc#gluScaleImage + * @see GLFunc#glPixelStorei + */ + public boolean scaleTexture2Pow2() + { + if(pixelScaled) + return true; + + 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}; + + setTextureSize(); + + if (textWidth != imageWidth || + textHeight != imageHeight) + { + int colorBytes; + + // speicher fuer scaliertes bild anlegen + byte[] buffer=new byte[textWidth * textHeight * + getComponents()]; + + /* 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); + + if( glu.gluScaleImage(glFormat, + imageWidth, imageHeight, + GL_UNSIGNED_BYTE, + pixel, + textWidth, textHeight, + GL_UNSIGNED_BYTE, + buffer)!=0 ) + { + // glu failure + error=true; + } else { + pixel = buffer; + } + + 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 can be called, + * if you want to have an optimal image-data size + * which fits best into the texture-MEMORY ! + * + * The Ascpect-Ratio is not changed + * - seen from the texture-MEMORY-ratio + * to the netto-image-MEMORY-ratio ! + * + * If you want to render this result with the correct + * apsect-ration, + * you MUST set the vertices in relation to + * the textureWidth and textureHeight ! + * Look in the demo: "demos/MiscDemos/GLImageWorld1" ! + * + * You can call this method directly after loading a + * texture ! + * + * The pixel store mode GL_UNPACK_ALIGNMENT & GL_PACK_ALIGNMENT, + * is set temporary to byte alignment, then back to default (4) ! + * + * The pixel store mode GL_UNPACK_ROW_LENGTH & GL_PACK_ROW_LENGTH, + * is set temporary to imageWidth, then back to default (0) ! + * + * @see GLUFunc#gluScaleImage + * @see GLFunc#glPixelStorei + */ + public boolean scaleTexture4BestSize() + { + if(pixelScaled) + return true; + + setTextureSize(); + + if (textWidth != imageWidth || + textHeight != imageHeight) + { + 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}; + int colorBytes; + + // speicher fuer scaliertes bild anlegen + byte[] buffer=new byte[textWidth * textHeight * + getComponents()]; + + int w=textWidth; + int h=textHeight; + + double iaspect = (double)imageWidth/ + (double)imageHeight; + + if(textWidth<textHeight) + h = (int) ((textWidth / iaspect)+0.5); + else + w = (int) ((textHeight * iaspect)+0.5); + + /* + System.out.println("scale4Best: size "+ + imageWidth+"/"+imageHeight+" -> "+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"); + } +} + |