Class GL10


public final class GL10 extends GL10C
GL10 relies on preview features of the Java platform:
Programs can only use GL10 when preview features are enabled.
Preview features may be removed in a future release, or upgraded to permanent features of the Java platform.
The OpenGL 1.0 functions.
Since:
0.1.0
Author:
squid233
  • Constructor Details

    • GL10

      public GL10()
  • Method Details

    • accum

      public static void accum(int op, float value)
    • alphaFunc

      public static void alphaFunc(int func, float ref)
    • begin

      public static void begin(int mode)
    • bitmap

      public static void bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, MemorySegmentPREVIEW bitmap)
    • callList

      public static void callList(int list)
    • callLists

      public static void callLists(int n, int type, MemorySegmentPREVIEW lists)
    • clearAccum

      public static void clearAccum(float red, float green, float blue, float alpha)
    • clearIndex

      public static void clearIndex(float c)
    • clipPlane

      public static void clipPlane(int plane, MemorySegmentPREVIEW equation)
    • clipPlane

      public static void clipPlane(SegmentAllocatorPREVIEW allocator, int plane, double[] equation)
    • color3b

      public static void color3b(byte red, byte green, byte blue)
    • color3bv

      public static void color3bv(MemorySegmentPREVIEW v)
    • color3bv

      public static void color3bv(SegmentAllocatorPREVIEW allocator, byte[] v)
    • color3d

      public static void color3d(double red, double green, double blue)
    • color3dv

      public static void color3dv(MemorySegmentPREVIEW v)
    • color3dv

      public static void color3dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • color3f

      public static void color3f(float red, float green, float blue)
    • color3fv

      public static void color3fv(MemorySegmentPREVIEW v)
    • color3fv

      public static void color3fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • color3i

      public static void color3i(int red, int green, int blue)
    • color3iv

      public static void color3iv(MemorySegmentPREVIEW v)
    • color3iv

      public static void color3iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • color3s

      public static void color3s(short red, short green, short blue)
    • color3sv

      public static void color3sv(MemorySegmentPREVIEW v)
    • color3sv

      public static void color3sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • color3ub

      public static void color3ub(byte red, byte green, byte blue)
    • color3ubv

      public static void color3ubv(MemorySegmentPREVIEW v)
    • color3ubv

      public static void color3ubv(SegmentAllocatorPREVIEW allocator, byte[] v)
    • color3ui

      public static void color3ui(int red, int green, int blue)
    • color3uiv

      public static void color3uiv(MemorySegmentPREVIEW v)
    • color3uiv

      public static void color3uiv(SegmentAllocatorPREVIEW allocator, int[] v)
    • color3us

      public static void color3us(short red, short green, short blue)
    • color3usv

      public static void color3usv(MemorySegmentPREVIEW v)
    • color3usv

      public static void color3usv(SegmentAllocatorPREVIEW allocator, short[] v)
    • color4b

      public static void color4b(byte red, byte green, byte blue, byte alpha)
    • color4bv

      public static void color4bv(MemorySegmentPREVIEW v)
    • color4bv

      public static void color4bv(SegmentAllocatorPREVIEW allocator, byte[] v)
    • color4d

      public static void color4d(double red, double green, double blue, double alpha)
    • color4dv

      public static void color4dv(MemorySegmentPREVIEW v)
    • color4dv

      public static void color4dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • color4f

      public static void color4f(float red, float green, float blue, float alpha)
    • color4fv

      public static void color4fv(MemorySegmentPREVIEW v)
    • color4fv

      public static void color4fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • color4i

      public static void color4i(int red, int green, int blue, int alpha)
    • color4iv

      public static void color4iv(MemorySegmentPREVIEW v)
    • color4iv

      public static void color4iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • color4s

      public static void color4s(short red, short green, short blue, short alpha)
    • color4sv

      public static void color4sv(MemorySegmentPREVIEW v)
    • color4sv

      public static void color4sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • color4ub

      public static void color4ub(byte red, byte green, byte blue, byte alpha)
    • color4ubv

      public static void color4ubv(MemorySegmentPREVIEW v)
    • color4ubv

      public static void color4ubv(SegmentAllocatorPREVIEW allocator, byte[] v)
    • color4ui

      public static void color4ui(int red, int green, int blue, int alpha)
    • color4uiv

      public static void color4uiv(MemorySegmentPREVIEW v)
    • color4uiv

      public static void color4uiv(SegmentAllocatorPREVIEW allocator, int[] v)
    • color4us

      public static void color4us(short red, short green, short blue, short alpha)
    • color4usv

      public static void color4usv(MemorySegmentPREVIEW v)
    • color4usv

      public static void color4usv(SegmentAllocatorPREVIEW allocator, short[] v)
    • colorMaterial

      public static void colorMaterial(int face, int mode)
    • copyPixels

      public static void copyPixels(int x, int y, int width, int height, int type)
    • deleteLists

      public static void deleteLists(int list, int range)
    • drawPixels

      public static void drawPixels(int width, int height, int format, int type, MemorySegmentPREVIEW pixels)
    • edgeFlag

      public static void edgeFlag(boolean flag)
    • edgeFlagv

      public static void edgeFlagv(MemorySegmentPREVIEW flag)
    • edgeFlagv

      public static void edgeFlagv(SegmentAllocatorPREVIEW allocator, boolean[] flag)
    • end

      public static void end()
    • endList

      public static void endList()
    • evalCoord1d

      public static void evalCoord1d(double u)
    • evalCoord1dv

      public static void evalCoord1dv(MemorySegmentPREVIEW u)
    • evalCoord1dv

      public static void evalCoord1dv(SegmentAllocatorPREVIEW allocator, double[] u)
    • evalCoord1f

      public static void evalCoord1f(float u)
    • evalCoord1fv

      public static void evalCoord1fv(MemorySegmentPREVIEW u)
    • evalCoord1fv

      public static void evalCoord1fv(SegmentAllocatorPREVIEW allocator, float[] u)
    • evalCoord2d

      public static void evalCoord2d(double u, double v)
    • evalCoord2dv

      public static void evalCoord2dv(MemorySegmentPREVIEW u)
    • evalCoord2dv

      public static void evalCoord2dv(SegmentAllocatorPREVIEW allocator, double[] u)
    • evalCoord2f

      public static void evalCoord2f(float u, float v)
    • evalCoord2fv

      public static void evalCoord2fv(MemorySegmentPREVIEW u)
    • evalCoord2fv

      public static void evalCoord2fv(SegmentAllocatorPREVIEW allocator, float[] u)
    • evalMesh1

      public static void evalMesh1(int mode, int i1, int i2)
    • evalMesh2

      public static void evalMesh2(int mode, int i1, int i2, int j1, int j2)
    • evalPoint1

      public static void evalPoint1(int mode, int i)
    • evalPoint2

      public static void evalPoint2(int mode, int i, int j)
    • feedbackBuffer

      public static void feedbackBuffer(int size, int type, MemorySegmentPREVIEW buffer)
    • feedbackBuffer

      public static void feedbackBuffer(SegmentAllocatorPREVIEW allocator, int type, float[] buffer)
    • fogf

      public static void fogf(int pname, float param)
    • fogfv

      public static void fogfv(int pname, MemorySegmentPREVIEW params)
    • fogfv

      public static void fogfv(SegmentAllocatorPREVIEW allocator, int pname, float[] params)
    • fogi

      public static void fogi(int pname, int param)
    • fogiv

      public static void fogiv(int pname, MemorySegmentPREVIEW params)
    • fogiv

      public static void fogiv(SegmentAllocatorPREVIEW allocator, int pname, int[] params)
    • frustum

      public static void frustum(double left, double right, double bottom, double top, double zNear, double zFar)
    • genLists

      public static int genLists(int range)
    • getClipPlane

      public static void getClipPlane(int plane, MemorySegmentPREVIEW equation)
    • getClipPlane

      public static double[] getClipPlane(int plane)
    • getLightfv

      public static void getLightfv(int light, int pname, MemorySegmentPREVIEW params)
    • getLightfv

      public static void getLightfv(SegmentAllocatorPREVIEW allocator, int light, int pname, float[] params)
    • getLightf

      public static float getLightf(int light, int pname)
    • getLightiv

      public static void getLightiv(int light, int pname, MemorySegmentPREVIEW params)
    • getLightiv

      public static void getLightiv(SegmentAllocatorPREVIEW allocator, int light, int pname, int[] params)
    • getLighti

      public static int getLighti(int light, int pname)
    • getMapdv

      public static void getMapdv(int target, int query, MemorySegmentPREVIEW v)
    • getMapdv

      public static void getMapdv(SegmentAllocatorPREVIEW allocator, int target, int query, double[] v)
    • getMapd

      public static double getMapd(int target, int query)
    • getMapfv

      public static void getMapfv(int target, int query, MemorySegmentPREVIEW v)
    • getMapfv

      public static void getMapfv(SegmentAllocatorPREVIEW allocator, int target, int query, float[] v)
    • getMapf

      public static float getMapf(int target, int query)
    • getMapiv

      public static void getMapiv(int target, int query, MemorySegmentPREVIEW v)
    • getMapiv

      public static void getMapiv(SegmentAllocatorPREVIEW allocator, int target, int query, int[] v)
    • getMapi

      public static int getMapi(int target, int query)
    • getMaterialfv

      public static void getMaterialfv(int face, int pname, MemorySegmentPREVIEW params)
    • getMaterialfv

      public static void getMaterialfv(SegmentAllocatorPREVIEW allocator, int face, int pname, float[] params)
    • getMaterialf

      public static float getMaterialf(int face, int pname)
    • getMaterialiv

      public static void getMaterialiv(int face, int pname, MemorySegmentPREVIEW params)
    • getMaterialiv

      public static void getMaterialiv(SegmentAllocatorPREVIEW allocator, int face, int pname, int[] params)
    • getMateriali

      public static int getMateriali(int face, int pname)
    • getPixelMapfv

      public static void getPixelMapfv(int map, MemorySegmentPREVIEW values)
    • getPixelMapfv

      public static void getPixelMapfv(SegmentAllocatorPREVIEW allocator, int map, float[] values)
    • getPixelMapuiv

      public static void getPixelMapuiv(int map, MemorySegmentPREVIEW values)
    • getPixelMapuiv

      public static void getPixelMapuiv(SegmentAllocatorPREVIEW allocator, int map, int[] values)
    • getPixelMapusv

      public static void getPixelMapusv(int map, MemorySegmentPREVIEW values)
    • getPixelMapusv

      public static void getPixelMapusv(SegmentAllocatorPREVIEW allocator, int map, short[] values)
    • getPolygonStipple

      public static void getPolygonStipple(MemorySegmentPREVIEW mask)
    • getPolygonStipple

      public static void getPolygonStipple(SegmentAllocatorPREVIEW allocator, byte[] mask)
    • getTexEnvfv

      public static void getTexEnvfv(int target, int pname, MemorySegmentPREVIEW params)
    • getTexEnvfv

      public static void getTexEnvfv(SegmentAllocatorPREVIEW allocator, int target, int pname, float[] params)
    • getTexEnvf

      public static float getTexEnvf(int target, int pname)
    • getTexEnviv

      public static void getTexEnviv(int target, int pname, MemorySegmentPREVIEW params)
    • getTexEnviv

      public static void getTexEnviv(SegmentAllocatorPREVIEW allocator, int target, int pname, int[] params)
    • getTexEnvi

      public static int getTexEnvi(int target, int pname)
    • getTexGendv

      public static void getTexGendv(int coord, int pname, MemorySegmentPREVIEW params)
    • getTexGendv

      public static void getTexGendv(SegmentAllocatorPREVIEW allocator, int coord, int pname, double[] params)
    • getTexGenfv

      public static void getTexGenfv(int coord, int pname, MemorySegmentPREVIEW params)
    • getTexGenfv

      public static void getTexGenfv(SegmentAllocatorPREVIEW allocator, int coord, int pname, float[] params)
    • getTexGeniv

      public static void getTexGeniv(int coord, int pname, MemorySegmentPREVIEW params)
    • getTexGeniv

      public static void getTexGeniv(SegmentAllocatorPREVIEW allocator, int coord, int pname, int[] params)
    • indexMask

      public static void indexMask(int mask)
    • indexd

      public static void indexd(double c)
    • indexdv

      public static void indexdv(MemorySegmentPREVIEW c)
    • indexdv

      public static void indexdv(SegmentAllocatorPREVIEW allocator, double[] c)
    • indexf

      public static void indexf(float c)
    • indexfv

      public static void indexfv(MemorySegmentPREVIEW c)
    • indexfv

      public static void indexfv(SegmentAllocatorPREVIEW allocator, float[] c)
    • indexi

      public static void indexi(int c)
    • indexiv

      public static void indexiv(MemorySegmentPREVIEW c)
    • indexiv

      public static void indexiv(SegmentAllocatorPREVIEW allocator, int[] c)
    • indexs

      public static void indexs(short c)
    • indexsv

      public static void indexsv(MemorySegmentPREVIEW c)
    • indexsv

      public static void indexsv(SegmentAllocatorPREVIEW allocator, short[] c)
    • initNames

      public static void initNames()
    • isList

      public static boolean isList(int list)
    • lightModelf

      public static void lightModelf(int pname, float param)
    • lightModelfv

      public static void lightModelfv(int pname, MemorySegmentPREVIEW params)
    • lightModelfv

      public static void lightModelfv(SegmentAllocatorPREVIEW allocator, int pname, float[] params)
    • lightModeli

      public static void lightModeli(int pname, int param)
    • lightModeliv

      public static void lightModeliv(int pname, MemorySegmentPREVIEW params)
    • lightModeliv

      public static void lightModeliv(SegmentAllocatorPREVIEW allocator, int pname, int[] params)
    • lightf

      public static void lightf(int light, int pname, float param)
    • lightfv

      public static void lightfv(int light, int pname, MemorySegmentPREVIEW params)
    • lightfv

      public static void lightfv(SegmentAllocatorPREVIEW allocator, int light, int pname, float[] params)
    • lighti

      public static void lighti(int light, int pname, int param)
    • lightiv

      public static void lightiv(int light, int pname, MemorySegmentPREVIEW params)
    • lightiv

      public static void lightiv(SegmentAllocatorPREVIEW allocator, int light, int pname, int[] params)
    • lineStipple

      public static void lineStipple(int factor, short pattern)
    • listBase

      public static void listBase(int base)
    • loadIdentity

      public static void loadIdentity()
    • loadMatrixd

      public static void loadMatrixd(MemorySegmentPREVIEW m)
    • loadMatrixd

      public static void loadMatrixd(SegmentAllocatorPREVIEW allocator, double[] m)
    • loadMatrixf

      public static void loadMatrixf(MemorySegmentPREVIEW m)
    • loadMatrixf

      public static void loadMatrixf(SegmentAllocatorPREVIEW allocator, float[] m)
    • loadName

      public static void loadName(int name)
    • map1d

      public static void map1d(int target, double u1, double u2, int stride, int order, MemorySegmentPREVIEW points)
    • map1d

      public static void map1d(SegmentAllocatorPREVIEW allocator, int target, double u1, double u2, int stride, int order, double[] points)
    • map1f

      public static void map1f(int target, float u1, float u2, int stride, int order, MemorySegmentPREVIEW points)
    • map1f

      public static void map1f(SegmentAllocatorPREVIEW allocator, int target, float u1, float u2, int stride, int order, float[] points)
    • map2d

      public static void map2d(int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, MemorySegmentPREVIEW points)
    • map2d

      public static void map2d(SegmentAllocatorPREVIEW allocator, int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points)
    • map2f

      public static void map2f(int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, MemorySegmentPREVIEW points)
    • map2f

      public static void map2f(SegmentAllocatorPREVIEW allocator, int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points)
    • mapGrid1d

      public static void mapGrid1d(int un, double u1, double u2)
    • mapGrid1f

      public static void mapGrid1f(int un, float u1, float u2)
    • mapGrid2d

      public static void mapGrid2d(int un, double u1, double u2, int vn, double v1, double v2)
    • mapGrid2f

      public static void mapGrid2f(int un, float u1, float u2, int vn, float v1, float v2)
    • materialf

      public static void materialf(int face, int pname, float param)
    • materialfv

      public static void materialfv(int face, int pname, MemorySegmentPREVIEW params)
    • materialfv

      public static void materialfv(SegmentAllocatorPREVIEW allocator, int face, int pname, float[] params)
    • materiali

      public static void materiali(int face, int pname, int param)
    • materialiv

      public static void materialiv(int face, int pname, MemorySegmentPREVIEW params)
    • materialiv

      public static void materialiv(SegmentAllocatorPREVIEW allocator, int face, int pname, int[] params)
    • matrixMode

      public static void matrixMode(int mode)
    • multMatrixd

      public static void multMatrixd(MemorySegmentPREVIEW m)
    • multMatrixd

      public static void multMatrixd(SegmentAllocatorPREVIEW allocator, double[] m)
    • multMatrixf

      public static void multMatrixf(MemorySegmentPREVIEW m)
    • multMatrixf

      public static void multMatrixf(SegmentAllocatorPREVIEW allocator, float[] m)
    • newList

      public static void newList(int list, int mode)
    • normal3b

      public static void normal3b(byte nx, byte ny, byte nz)
    • normal3bv

      public static void normal3bv(MemorySegmentPREVIEW v)
    • normal3bv

      public static void normal3bv(SegmentAllocatorPREVIEW allocator, byte[] v)
    • normal3d

      public static void normal3d(double nx, double ny, double nz)
    • normal3dv

      public static void normal3dv(MemorySegmentPREVIEW v)
    • normal3dv

      public static void normal3dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • normal3f

      public static void normal3f(float nx, float ny, float nz)
    • normal3fv

      public static void normal3fv(MemorySegmentPREVIEW v)
    • normal3fv

      public static void normal3fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • normal3i

      public static void normal3i(int nx, int ny, int nz)
    • normal3iv

      public static void normal3iv(MemorySegmentPREVIEW v)
    • normal3iv

      public static void normal3iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • normal3s

      public static void normal3s(short nx, short ny, short nz)
    • normal3sv

      public static void normal3sv(MemorySegmentPREVIEW v)
    • normal3sv

      public static void normal3sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • ortho

      public static void ortho(double left, double right, double bottom, double top, double zNear, double zFar)
    • passThrough

      public static void passThrough(float token)
    • pixelMapfv

      public static void pixelMapfv(int map, int mapSize, MemorySegmentPREVIEW values)
    • pixelMapfv

      public static void pixelMapfv(SegmentAllocatorPREVIEW allocator, int map, float[] values)
    • pixelMapuiv

      public static void pixelMapuiv(int map, int mapSize, MemorySegmentPREVIEW values)
    • pixelMapuiv

      public static void pixelMapuiv(SegmentAllocatorPREVIEW allocator, int map, int[] values)
    • pixelMapusv

      public static void pixelMapusv(int map, int mapSize, MemorySegmentPREVIEW values)
    • pixelMapusv

      public static void pixelMapusv(SegmentAllocatorPREVIEW allocator, int map, short[] values)
    • pixelTransferf

      public static void pixelTransferf(int pname, float param)
    • pixelTransferi

      public static void pixelTransferi(int pname, int param)
    • pixelZoom

      public static void pixelZoom(float xfactor, float yfactor)
    • polygonStipple

      public static void polygonStipple(MemorySegmentPREVIEW mask)
    • polygonStipple

      public static void polygonStipple(SegmentAllocatorPREVIEW allocator, byte[] mask)
    • popAttrib

      public static void popAttrib()
    • popMatrix

      public static void popMatrix()
    • popName

      public static void popName()
    • pushAttrib

      public static void pushAttrib(int mask)
    • pushMatrix

      public static void pushMatrix()
    • pushName

      public static void pushName(int name)
    • rasterPos2d

      public static void rasterPos2d(double x, double y)
    • rasterPos2dv

      public static void rasterPos2dv(MemorySegmentPREVIEW v)
    • rasterPos2dv

      public static void rasterPos2dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • rasterPos2f

      public static void rasterPos2f(float x, float y)
    • rasterPos2fv

      public static void rasterPos2fv(MemorySegmentPREVIEW v)
    • rasterPos2fv

      public static void rasterPos2fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • rasterPos2i

      public static void rasterPos2i(int x, int y)
    • rasterPos2iv

      public static void rasterPos2iv(MemorySegmentPREVIEW v)
    • rasterPos2iv

      public static void rasterPos2iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • rasterPos2s

      public static void rasterPos2s(short x, short y)
    • rasterPos2sv

      public static void rasterPos2sv(MemorySegmentPREVIEW v)
    • rasterPos2sv

      public static void rasterPos2sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • rasterPos3d

      public static void rasterPos3d(double x, double y, double z)
    • rasterPos3dv

      public static void rasterPos3dv(MemorySegmentPREVIEW v)
    • rasterPos3dv

      public static void rasterPos3dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • rasterPos3f

      public static void rasterPos3f(float x, float y, float z)
    • rasterPos3fv

      public static void rasterPos3fv(MemorySegmentPREVIEW v)
    • rasterPos3fv

      public static void rasterPos3fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • rasterPos3i

      public static void rasterPos3i(int x, int y, int z)
    • rasterPos3iv

      public static void rasterPos3iv(MemorySegmentPREVIEW v)
    • rasterPos3iv

      public static void rasterPos3iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • rasterPos3s

      public static void rasterPos3s(short x, short y, short z)
    • rasterPos3sv

      public static void rasterPos3sv(MemorySegmentPREVIEW v)
    • rasterPos3sv

      public static void rasterPos3sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • rasterPos4d

      public static void rasterPos4d(double x, double y, double z, double w)
    • rasterPos4dv

      public static void rasterPos4dv(MemorySegmentPREVIEW v)
    • rasterPos4dv

      public static void rasterPos4dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • rasterPos4f

      public static void rasterPos4f(float x, float y, float z, float w)
    • rasterPos4fv

      public static void rasterPos4fv(MemorySegmentPREVIEW v)
    • rasterPos4fv

      public static void rasterPos4fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • rasterPos4i

      public static void rasterPos4i(int x, int y, int z, int w)
    • rasterPos4iv

      public static void rasterPos4iv(MemorySegmentPREVIEW v)
    • rasterPos4iv

      public static void rasterPos4iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • rasterPos4s

      public static void rasterPos4s(short x, short y, short z, short w)
    • rasterPos4sv

      public static void rasterPos4sv(MemorySegmentPREVIEW v)
    • rasterPos4sv

      public static void rasterPos4sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • rectd

      public static void rectd(double x1, double y1, double x2, double y2)
    • rectdv

      public static void rectdv(MemorySegmentPREVIEW v1, MemorySegmentPREVIEW v2)
    • rectdv

      public static void rectdv(SegmentAllocatorPREVIEW allocator, double[] v1, double[] v2)
    • rectf

      public static void rectf(float x1, float y1, float x2, float y2)
    • rectfv

      public static void rectfv(MemorySegmentPREVIEW v1, MemorySegmentPREVIEW v2)
    • rectfv

      public static void rectfv(SegmentAllocatorPREVIEW allocator, float[] v1, float[] v2)
    • recti

      public static void recti(int x1, int y1, int x2, int y2)
    • rectiv

      public static void rectiv(MemorySegmentPREVIEW v1, MemorySegmentPREVIEW v2)
    • rectiv

      public static void rectiv(SegmentAllocatorPREVIEW allocator, int[] v1, int[] v2)
    • rects

      public static void rects(short x1, short y1, short x2, short y2)
    • rectsv

      public static void rectsv(MemorySegmentPREVIEW v1, MemorySegmentPREVIEW v2)
    • rectsv

      public static void rectsv(SegmentAllocatorPREVIEW allocator, short[] v1, short[] v2)
    • renderMode

      public static int renderMode(int mode)
    • rotated

      public static void rotated(double angle, double x, double y, double z)
    • rotatef

      public static void rotatef(float angle, float x, float y, float z)
    • scaled

      public static void scaled(double x, double y, double z)
    • scalef

      public static void scalef(float x, float y, float z)
    • selectBuffer

      public static void selectBuffer(int size, MemorySegmentPREVIEW buffer)
    • selectBuffer

      public static void selectBuffer(SegmentAllocatorPREVIEW allocator, int[] buffer)
    • shadeModel

      public static void shadeModel(int mode)
    • texCoord1d

      public static void texCoord1d(double s)
    • texCoord1dv

      public static void texCoord1dv(MemorySegmentPREVIEW v)
    • texCoord1dv

      public static void texCoord1dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • texCoord1f

      public static void texCoord1f(float s)
    • texCoord1fv

      public static void texCoord1fv(MemorySegmentPREVIEW v)
    • texCoord1fv

      public static void texCoord1fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • texCoord1i

      public static void texCoord1i(int s)
    • texCoord1iv

      public static void texCoord1iv(MemorySegmentPREVIEW v)
    • texCoord1iv

      public static void texCoord1iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • texCoord1s

      public static void texCoord1s(short s)
    • texCoord1sv

      public static void texCoord1sv(MemorySegmentPREVIEW v)
    • texCoord1sv

      public static void texCoord1sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • texCoord2d

      public static void texCoord2d(double s, double t)
    • texCoord2dv

      public static void texCoord2dv(MemorySegmentPREVIEW v)
    • texCoord2dv

      public static void texCoord2dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • texCoord2f

      public static void texCoord2f(float s, float t)
    • texCoord2fv

      public static void texCoord2fv(MemorySegmentPREVIEW v)
    • texCoord2fv

      public static void texCoord2fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • texCoord2i

      public static void texCoord2i(int s, int t)
    • texCoord2iv

      public static void texCoord2iv(MemorySegmentPREVIEW v)
    • texCoord2iv

      public static void texCoord2iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • texCoord2s

      public static void texCoord2s(short s, short t)
    • texCoord2sv

      public static void texCoord2sv(MemorySegmentPREVIEW v)
    • texCoord2sv

      public static void texCoord2sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • texCoord3d

      public static void texCoord3d(double s, double t, double r)
    • texCoord3dv

      public static void texCoord3dv(MemorySegmentPREVIEW v)
    • texCoord3dv

      public static void texCoord3dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • texCoord3f

      public static void texCoord3f(float s, float t, float r)
    • texCoord3fv

      public static void texCoord3fv(MemorySegmentPREVIEW v)
    • texCoord3fv

      public static void texCoord3fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • texCoord3i

      public static void texCoord3i(int s, int t, int r)
    • texCoord3iv

      public static void texCoord3iv(MemorySegmentPREVIEW v)
    • texCoord3iv

      public static void texCoord3iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • texCoord3s

      public static void texCoord3s(short s, short t, short r)
    • texCoord3sv

      public static void texCoord3sv(MemorySegmentPREVIEW v)
    • texCoord3sv

      public static void texCoord3sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • texCoord4d

      public static void texCoord4d(double s, double t, double r, double q)
    • texCoord4dv

      public static void texCoord4dv(MemorySegmentPREVIEW v)
    • texCoord4dv

      public static void texCoord4dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • texCoord4f

      public static void texCoord4f(float s, float t, float r, float q)
    • texCoord4fv

      public static void texCoord4fv(MemorySegmentPREVIEW v)
    • texCoord4fv

      public static void texCoord4fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • texCoord4i

      public static void texCoord4i(int s, int t, int r, int q)
    • texCoord4iv

      public static void texCoord4iv(MemorySegmentPREVIEW v)
    • texCoord4iv

      public static void texCoord4iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • texCoord4s

      public static void texCoord4s(short s, short t, short r, short q)
    • texCoord4sv

      public static void texCoord4sv(MemorySegmentPREVIEW v)
    • texCoord4sv

      public static void texCoord4sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • texEnvf

      public static void texEnvf(int target, int pname, float param)
    • texEnvfv

      public static void texEnvfv(int target, int pname, MemorySegmentPREVIEW params)
    • texEnvfv

      public static void texEnvfv(SegmentAllocatorPREVIEW allocator, int target, int pname, float[] params)
    • texEnvi

      public static void texEnvi(int target, int pname, int param)
    • texEnviv

      public static void texEnviv(int target, int pname, MemorySegmentPREVIEW params)
    • texEnviv

      public static void texEnviv(SegmentAllocatorPREVIEW allocator, int target, int pname, int[] params)
    • texGend

      public static void texGend(int coord, int pname, double param)
    • texGendv

      public static void texGendv(int coord, int pname, MemorySegmentPREVIEW params)
    • texGendv

      public static void texGendv(SegmentAllocatorPREVIEW allocator, int coord, int pname, double[] params)
    • texGenf

      public static void texGenf(int coord, int pname, float param)
    • texGenfv

      public static void texGenfv(int coord, int pname, MemorySegmentPREVIEW params)
    • texGenfv

      public static void texGenfv(SegmentAllocatorPREVIEW allocator, int coord, int pname, float[] params)
    • texGeni

      public static void texGeni(int coord, int pname, int param)
    • texGeniv

      public static void texGeniv(int coord, int pname, MemorySegmentPREVIEW params)
    • texGeniv

      public static void texGeniv(SegmentAllocatorPREVIEW allocator, int coord, int pname, int[] params)
    • translated

      public static void translated(double x, double y, double z)
    • translatef

      public static void translatef(float x, float y, float z)
    • vertex2d

      public static void vertex2d(double x, double y)
    • vertex2dv

      public static void vertex2dv(MemorySegmentPREVIEW v)
    • vertex2dv

      public static void vertex2dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • vertex2f

      public static void vertex2f(float x, float y)
    • vertex2fv

      public static void vertex2fv(MemorySegmentPREVIEW v)
    • vertex2fv

      public static void vertex2fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • vertex2i

      public static void vertex2i(int x, int y)
    • vertex2iv

      public static void vertex2iv(MemorySegmentPREVIEW v)
    • vertex2iv

      public static void vertex2iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • vertex2s

      public static void vertex2s(short x, short y)
    • vertex2sv

      public static void vertex2sv(MemorySegmentPREVIEW v)
    • vertex2sv

      public static void vertex2sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • vertex3d

      public static void vertex3d(double x, double y, double z)
    • vertex3dv

      public static void vertex3dv(MemorySegmentPREVIEW v)
    • vertex3dv

      public static void vertex3dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • vertex3f

      public static void vertex3f(float x, float y, float z)
    • vertex3fv

      public static void vertex3fv(MemorySegmentPREVIEW v)
    • vertex3fv

      public static void vertex3fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • vertex3i

      public static void vertex3i(int x, int y, int z)
    • vertex3iv

      public static void vertex3iv(MemorySegmentPREVIEW v)
    • vertex3iv

      public static void vertex3iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • vertex3s

      public static void vertex3s(short x, short y, short z)
    • vertex3sv

      public static void vertex3sv(MemorySegmentPREVIEW v)
    • vertex3sv

      public static void vertex3sv(SegmentAllocatorPREVIEW allocator, short[] v)
    • vertex4d

      public static void vertex4d(double x, double y, double z, double w)
    • vertex4dv

      public static void vertex4dv(MemorySegmentPREVIEW v)
    • vertex4dv

      public static void vertex4dv(SegmentAllocatorPREVIEW allocator, double[] v)
    • vertex4f

      public static void vertex4f(float x, float y, float z, float w)
    • vertex4fv

      public static void vertex4fv(MemorySegmentPREVIEW v)
    • vertex4fv

      public static void vertex4fv(SegmentAllocatorPREVIEW allocator, float[] v)
    • vertex4i

      public static void vertex4i(int x, int y, int z, int w)
    • vertex4iv

      public static void vertex4iv(MemorySegmentPREVIEW v)
    • vertex4iv

      public static void vertex4iv(SegmentAllocatorPREVIEW allocator, int[] v)
    • vertex4s

      public static void vertex4s(short x, short y, short z, short w)
    • vertex4sv

      public static void vertex4sv(MemorySegmentPREVIEW v)
    • vertex4sv

      public static void vertex4sv(SegmentAllocatorPREVIEW allocator, short[] v)