From 8bf2d611943d47b1fb5417882812d0e8f4c4814b Mon Sep 17 00:00:00 2001 From: fersatgit <122711455+fersatgit@users.noreply.github.com> Date: Wed, 8 May 2024 13:45:08 +0500 Subject: [PATCH] Add files via upload --- 1.png | Bin 0 -> 62489 bytes 1.res | Bin 0 -> 792 bytes GDIPlus.pas | 2198 +++++++++++++ IWFCam.dpr | 764 +++++ MFAPI.pas | 961 ++++++ OpenGL.pas | 8655 +++++++++++++++++++++++++++++++++++++++++++++++++++ README.md | 6 + 7 files changed, 12584 insertions(+) create mode 100644 1.png create mode 100644 1.res create mode 100644 GDIPlus.pas create mode 100644 IWFCam.dpr create mode 100644 MFAPI.pas create mode 100644 OpenGL.pas create mode 100644 README.md diff --git a/1.png b/1.png new file mode 100644 index 0000000000000000000000000000000000000000..520a656000d79c5d3611d3a7599ff67c3632efe5 GIT binary patch literal 62489 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 U!)K#E@8N$s8iwF{HT$Ul1A0%#i2wiq literal 0 HcmV?d00001 diff --git a/1.res b/1.res new file mode 100644 index 0000000000000000000000000000000000000000..f5e553e59e34df60f411ff608ccd88507cc6baf2 GIT binary patch literal 792 zcmZQzU|>)H;{X347|28c3z=Z@%s@4aU^xQ;gp$qxKX+a(DK4N0ucwDg5Ri5NVHRc} z8R4Gu7D!11_=LE!FtJ3nKiPZ!OV_G5KmYu3DZ8_1*Zbm`&((^{{efy2OM?7@862M7 zNMm4NGWT?G45^4~ofg=CTY;xxaqcbt8;5NDEjK;S<*JUe++L|R<;hpS>)+yD5X3miAQsvy%toQIF!-MPAYqh3rV)DLyV4?D)TJ{5-wch8>XPEXz@c~c5)I|$yCgdmXVBi;eVEt?=yQkE{eFX~+eP$PD zR<_)5;L{V1P)-NA+ND~ZEYt3Dh%+-+ZkcnOxqAP;BM$DKy-!+$XJmNt$eh$|Eo{AJ z*;z6@#j(5fsQ+_iosX;C&oTv6taIMl68?1cE1nk>+?|C}H@t7W-5$mt%roJ+;5m2O z^0q_Md>f~2QQj`S@x_*N4J&V+cj#U9H}=322j){<8;&+Oh^geCa*SfSWYWJTG44x4 zO`L`p_pMTvB}?U=J^B?io#EBD4JrkaJhIm~KYrO!UUTM6UJ=8uWr<(z7=%AKoRfUO zGwN!~G-dtYdotM*GHb)Nr*E&d-(GuC@rn5J)hrbvpV$9+GD>50M9)z4*}Q$iDv gDFVa_K>YtdAJ#MsOnpG;;2;1bSr{^aX_=7$036vvr~m)} literal 0 HcmV?d00001 diff --git a/GDIPlus.pas b/GDIPlus.pas new file mode 100644 index 0000000..5d34bf7 --- /dev/null +++ b/GDIPlus.pas @@ -0,0 +1,2198 @@ +unit GDIPlus; + +{$ALIGN ON} +{$W-} +{$MINENUMSIZE 4} + +interface + +uses + Windows; + +type + tagSTATSTG =record + pwcsName: PWideChar; + dwType: Longint; + cbSize: int64; + mtime: TFileTime; + ctime: TFileTime; + atime: TFileTime; + grfMode: Longint; + grfLocksSupported: Longint; + clsid: TGUID; + grfStateBits: Longint; + reserved: Longint; + end; + + ISequentialStream = interface(IUnknown) + ['{0c733a30-2a1c-11ce-ade5-00aa0044773d}'] + function Read(pv: Pointer; cb: Longint; pcbRead: PLongint): LongInt;stdcall; + function Write(pv: Pointer; cb: Longint; pcbWritten: PLongint): LongInt;stdcall; + end; + + IStream = interface(ISequentialStream) + ['{0000000C-0000-0000-C000-000000000046}'] + function Seek(dlibMove: int64; dwOrigin: Longint; libNewPosition: pint64): LongInt; stdcall; + function SetSize(libNewSize: int64): LongInt; stdcall; + function CopyTo(stm: IStream; cb: int64; out cbRead: int64; cbWritten: pint64): LongInt; stdcall; + function Commit(grfCommitFlags: Longint): LongInt; stdcall; + function Revert: LongInt; stdcall; + function LockRegion(libOffset: int64; cb: int64; dwLockType: Longint): LongInt; stdcall; + function UnlockRegion(libOffset: int64; cb: int64; dwLockType: Longint): LongInt; stdcall; + function Stat(out statstg: tagSTATSTG; grfStatFlag: Longint): LongInt;stdcall; + function Clone(out stm: IStream): LongInt; stdcall; + end; + + INT16 = type Smallint; + UINT16 = type Word; + PUINT16 = ^UINT16; + UINT32 = type Cardinal; + TSingleDynArray = array of Single; + + GraphicsState = UINT; + GraphicsContainer = UINT; + FillMode = ( + FillModeAlternate, // 0 + FillModeWinding // 1 + ); + TFillMode = FillMode; + + QualityMode = ( + QualityModeInvalid = -1, + QualityModeDefault = 0, + QualityModeLow = 1, // Best performance + QualityModeHigh = 2 // Best rendering quality + ); + TQualityMode = QualityMode; + + CompositingMode = ( + CompositingModeSourceOver, // 0 + CompositingModeSourceCopy // 1 + ); + TCompositingMode = CompositingMode; + + CompositingQuality = ( + CompositingQualityInvalid = ord(QualityModeInvalid), + CompositingQualityDefault = ord(QualityModeDefault), + CompositingQualityHighSpeed = ord(QualityModeLow), + CompositingQualityHighQuality = ord(QualityModeHigh), + CompositingQualityGammaCorrected, + CompositingQualityAssumeLinear + ); + TCompositingQuality = CompositingQuality; + + Unit_ = ( + UnitWorld, // 0 -- World coordinate (non-physical unit) + UnitDisplay, // 1 -- Variable -- for PageTransform only + UnitPixel, // 2 -- Each unit is one device pixel. + UnitPoint, // 3 -- Each unit is a printer's point, or 1/72 inch. + UnitInch, // 4 -- Each unit is 1 inch. + UnitDocument, // 5 -- Each unit is 1/300 inch. + UnitMillimeter // 6 -- Each unit is 1 millimeter. + ); + TUnit = Unit_; + + MetafileFrameUnit = ( + MetafileFrameUnitPixel = ord(UnitPixel), + MetafileFrameUnitPoint = ord(UnitPoint), + MetafileFrameUnitInch = ord(UnitInch), + MetafileFrameUnitDocument = ord(UnitDocument), + MetafileFrameUnitMillimeter = ord(UnitMillimeter), + MetafileFrameUnitGdi // GDI compatible .01 MM units + ); + TMetafileFrameUnit = MetafileFrameUnit; + + CoordinateSpace = ( + CoordinateSpaceWorld, // 0 + CoordinateSpacePage, // 1 + CoordinateSpaceDevice // 2 + ); + TCoordinateSpace = CoordinateSpace; + + WrapMode = ( + WrapModeTile, // 0 + WrapModeTileFlipX, // 1 + WrapModeTileFlipY, // 2 + WrapModeTileFlipXY, // 3 + WrapModeClamp // 4 + ); + TWrapMode = WrapMode; + + HatchStyle = ( + HatchStyleHorizontal = 0, + HatchStyleVertical = 1, + HatchStyleForwardDiagonal = 2, + HatchStyleBackwardDiagonal = 3, + HatchStyleCross = 4, + HatchStyleDiagonalCross = 5, + HatchStyle05Percent = 6, + HatchStyle10Percent = 7, + HatchStyle20Percent = 8, + HatchStyle25Percent = 9, + HatchStyle30Percent = 10, + HatchStyle40Percent = 11, + HatchStyle50Percent = 12, + HatchStyle60Percent = 13, + HatchStyle70Percent = 14, + HatchStyle75Percent = 15, + HatchStyle80Percent = 16, + HatchStyle90Percent = 17, + HatchStyleLightDownwardDiagonal = 18, + HatchStyleLightUpwardDiagonal = 19, + HatchStyleDarkDownwardDiagonal = 20, + HatchStyleDarkUpwardDiagonal = 21, + HatchStyleWideDownwardDiagonal = 22, + HatchStyleWideUpwardDiagonal = 23, + HatchStyleLightVertical = 24, + HatchStyleLightHorizontal = 25, + HatchStyleNarrowVertical = 26, + HatchStyleNarrowHorizontal = 27, + HatchStyleDarkVertical = 28, + HatchStyleDarkHorizontal = 29, + HatchStyleDashedDownwardDiagonal = 30, + HatchStyleDashedUpwardDiagonal = 31, + HatchStyleDashedHorizontal = 32, + HatchStyleDashedVertical = 33, + HatchStyleSmallConfetti = 34, + HatchStyleLargeConfetti = 35, + HatchStyleZigZag = 36, + HatchStyleWave = 37, + HatchStyleDiagonalBrick = 38, + HatchStyleHorizontalBrick = 39, + HatchStyleWeave = 40, + HatchStylePlaid = 41, + HatchStyleDivot = 42, + HatchStyleDottedGrid = 43, + HatchStyleDottedDiamond = 44, + HatchStyleShingle = 45, + HatchStyleTrellis = 46, + HatchStyleSphere = 47, + HatchStyleSmallGrid = 48, + HatchStyleSmallCheckerBoard = 49, + HatchStyleLargeCheckerBoard = 50, + HatchStyleOutlinedDiamond = 51, + HatchStyleSolidDiamond = 52, + + HatchStyleTotal = 53, + HatchStyleLargeGrid = HatchStyleCross, // 4 + + HatchStyleMin = HatchStyleHorizontal, + HatchStyleMax = HatchStyleTotal - 1); + THatchStyle = HatchStyle; + + DashStyle = ( + DashStyleSolid, // 0 + DashStyleDash, // 1 + DashStyleDot, // 2 + DashStyleDashDot, // 3 + DashStyleDashDotDot, // 4 + DashStyleCustom // 5 + ); + TDashStyle = DashStyle; + + DashCap = ( + DashCapFlat = 0, + DashCapRound = 2, + DashCapTriangle = 3); + TDashCap = DashCap; + + LineCap = ( + LineCapFlat = 0, + LineCapSquare = 1, + LineCapRound = 2, + LineCapTriangle = 3, + + LineCapNoAnchor = $10, // corresponds to flat cap + LineCapSquareAnchor = $11, // corresponds to square cap + LineCapRoundAnchor = $12, // corresponds to round cap + LineCapDiamondAnchor = $13, // corresponds to triangle cap + LineCapArrowAnchor = $14, // no correspondence + + LineCapCustom = $ff, // custom cap + + LineCapAnchorMask = $f0 // mask to check for anchor or not. + ); + TLineCap = LineCap; + + CustomLineCapType = ( + CustomLineCapTypeDefault = 0, + CustomLineCapTypeAdjustableArrow = 1); + TCustomLineCapType = CustomLineCapType; + + LineJoin = ( + LineJoinMiter = 0, + LineJoinBevel = 1, + LineJoinRound = 2, + LineJoinMiterClipped = 3); + TLineJoin = LineJoin; + + {$Z1} + PathPointType = ( + PathPointTypeStart = $00, // move + PathPointTypeLine = $01, // line + PathPointTypeBezier = $03, // default Bezier (= cubic Bezier) + PathPointTypePathTypeMask = $07, // type mask (lowest 3 bits). + PathPointTypeDashMode = $10, // currently in dash mode. + PathPointTypePathMarker = $20, // a marker for the path. + PathPointTypeCloseSubpath = $80, // closed flag + PathPointTypeBezier3 = $03 // cubic Bezier + ); + TPathPointType = PathPointType; + {$Z4} + + WarpMode = ( + WarpModePerspective, // 0 + WarpModeBilinear // 1 + ); + TWarpMode = WarpMode; + + LinearGradientMode = ( + LinearGradientModeHorizontal, // 0 + LinearGradientModeVertical, // 1 + LinearGradientModeForwardDiagonal, // 2 + LinearGradientModeBackwardDiagonal // 3 + ); + TLinearGradientMode = LinearGradientMode; + + CombineMode = ( + CombineModeReplace, // 0 + CombineModeIntersect, // 1 + CombineModeUnion, // 2 + CombineModeXor, // 3 + CombineModeExclude, // 4 + CombineModeComplement // 5 (Exclude From) + ); + TCombineMode = CombineMode; + + ImageType = ( + ImageTypeUnknown, // 0 + ImageTypeBitmap, // 1 + ImageTypeMetafile // 2 + ); + TImageType = ImageType; + + InterpolationMode = ( + InterpolationModeInvalid = ord(QualityModeInvalid), + InterpolationModeDefault = ord(QualityModeDefault), + InterpolationModeLowQuality = ord(QualityModeLow), + InterpolationModeHighQuality = ord(QualityModeHigh), + InterpolationModeBilinear, + InterpolationModeBicubic, + InterpolationModeNearestNeighbor, + InterpolationModeHighQualityBilinear, + InterpolationModeHighQualityBicubic); + TInterpolationMode = InterpolationMode; + + PenAlignment = ( + PenAlignmentCenter = 0, + PenAlignmentInset = 1); + TPenAlignment = PenAlignment; + + BrushType = ( + BrushTypeSolidColor = 0, + BrushTypeHatchFill = 1, + BrushTypeTextureFill = 2, + BrushTypePathGradient = 3, + BrushTypeLinearGradient = 4); + TBrushType = BrushType; + + PenType = ( + PenTypeSolidColor = ord(BrushTypeSolidColor), + PenTypeHatchFill = ord(BrushTypeHatchFill), + PenTypeTextureFill = ord(BrushTypeTextureFill), + PenTypePathGradient = ord(BrushTypePathGradient), + PenTypeLinearGradient = ord(BrushTypeLinearGradient), + PenTypeUnknown = -1); + TPenType = PenType; + + MatrixOrder = ( + MatrixOrderPrepend = 0, + MatrixOrderAppend = 1); + TMatrixOrder = MatrixOrder; + + GenericFontFamily = ( + GenericFontFamilySerif, + GenericFontFamilySansSerif, + GenericFontFamilyMonospace); + TGenericFontFamily = GenericFontFamily; + + FontStyle = Integer; + TFontStyle = FontStyle; + + SmoothingMode = ( + SmoothingModeInvalid = ord(QualityModeInvalid), + SmoothingModeDefault = ord(QualityModeDefault), + SmoothingModeHighSpeed = ord(QualityModeLow), + SmoothingModeHighQuality = ord(QualityModeHigh), + SmoothingModeNone, + SmoothingModeAntiAlias); + TSmoothingMode = SmoothingMode; + + PixelOffsetMode = ( + PixelOffsetModeInvalid = Ord(QualityModeInvalid), + PixelOffsetModeDefault = Ord(QualityModeDefault), + PixelOffsetModeHighSpeed = Ord(QualityModeLow), + PixelOffsetModeHighQuality = Ord(QualityModeHigh), + PixelOffsetModeNone, // No pixel offset + PixelOffsetModeHalf // Offset by -0.5, -0.5 for fast anti-alias perf + ); + TPixelOffsetMode = PixelOffsetMode; + + TextRenderingHint = ( + TextRenderingHintSystemDefault = 0, // Glyph with system default rendering hint + TextRenderingHintSingleBitPerPixelGridFit, // Glyph bitmap with hinting + TextRenderingHintSingleBitPerPixel, // Glyph bitmap without hinting + TextRenderingHintAntiAliasGridFit, // Glyph anti-alias bitmap with hinting + TextRenderingHintAntiAlias, // Glyph anti-alias bitmap without hinting + TextRenderingHintClearTypeGridFit // Glyph CT bitmap with hinting + ); + TTextRenderingHint = TextRenderingHint; + + MetafileType = ( + MetafileTypeInvalid, // Invalid metafile + MetafileTypeWmf, // Standard WMF + MetafileTypeWmfPlaceable, // Placeable WMF + MetafileTypeEmf, // EMF (not EMF+) + MetafileTypeEmfPlusOnly, // EMF+ without dual, down-level records + MetafileTypeEmfPlusDual // EMF+ with dual, down-level records + ); + TMetafileType = MetafileType; + + EmfType = ( + EmfTypeEmfOnly = Ord(MetafileTypeEmf), // no EMF+, only EMF + EmfTypeEmfPlusOnly = Ord(MetafileTypeEmfPlusOnly), // no EMF, only EMF+ + EmfTypeEmfPlusDual = Ord(MetafileTypeEmfPlusDual) // both EMF+ and EMF + ); + TEmfType = EmfType; + + ObjectType = ( + ObjectTypeInvalid, + ObjectTypeBrush, + ObjectTypePen, + ObjectTypePath, + ObjectTypeRegion, + ObjectTypeImage, + ObjectTypeFont, + ObjectTypeStringFormat, + ObjectTypeImageAttributes, + ObjectTypeCustomLineCap, + ObjectTypeMax = ObjectTypeCustomLineCap, + ObjectTypeMin = ObjectTypeBrush); + TObjectType = ObjectType; + + StringFormatFlags = Integer; + TStringFormatFlags = StringFormatFlags; + + StringTrimming = ( + StringTrimmingNone = 0, + StringTrimmingCharacter = 1, + StringTrimmingWord = 2, + StringTrimmingEllipsisCharacter = 3, + StringTrimmingEllipsisWord = 4, + StringTrimmingEllipsisPath = 5); + TStringTrimming = StringTrimming; + + StringDigitSubstitute = ( + StringDigitSubstituteUser = 0, // As NLS setting + StringDigitSubstituteNone = 1, + StringDigitSubstituteNational = 2, + StringDigitSubstituteTraditional = 3); + TStringDigitSubstitute = StringDigitSubstitute; + PStringDigitSubstitute = ^TStringDigitSubstitute; + + HotkeyPrefix = ( + HotkeyPrefixNone = 0, + HotkeyPrefixShow = 1, + HotkeyPrefixHide = 2); + THotkeyPrefix = HotkeyPrefix; + + StringAlignment = ( + StringAlignmentNear = 0, + StringAlignmentCenter = 1, + StringAlignmentFar = 2); + TStringAlignment = StringAlignment; + + DriverStringOptions = Integer; + TDriverStringOptions = DriverStringOptions; + FlushIntention = ( + FlushIntentionFlush = 0, // Flush all batched rendering operations + FlushIntentionSync = 1 // Flush all batched rendering operations and wait for them to complete + ); + TFlushIntention = FlushIntention; + + EncoderParameterValueType = Integer; + TEncoderParameterValueType = EncoderParameterValueType; + + EncoderValue = ( + EncoderValueColorTypeCMYK, + EncoderValueColorTypeYCCK, + EncoderValueCompressionLZW, + EncoderValueCompressionCCITT3, + EncoderValueCompressionCCITT4, + EncoderValueCompressionRle, + EncoderValueCompressionNone, + EncoderValueScanMethodInterlaced, + EncoderValueScanMethodNonInterlaced, + EncoderValueVersionGif87, + EncoderValueVersionGif89, + EncoderValueRenderProgressive, + EncoderValueRenderNonProgressive, + EncoderValueTransformRotate90, + EncoderValueTransformRotate180, + EncoderValueTransformRotate270, + EncoderValueTransformFlipHorizontal, + EncoderValueTransformFlipVertical, + EncoderValueMultiFrame, + EncoderValueLastFrame, + EncoderValueFlush, + EncoderValueFrameDimensionTime, + EncoderValueFrameDimensionResolution, + EncoderValueFrameDimensionPage); + TEncoderValue = EncoderValue; + + EmfToWmfBitsFlags = ( + EmfToWmfBitsFlagsDefault = $00000000, + EmfToWmfBitsFlagsEmbedEmf = $00000001, + EmfToWmfBitsFlagsIncludePlaceable = $00000002, + EmfToWmfBitsFlagsNoXORClip = $00000004); + TEmfToWmfBitsFlags = EmfToWmfBitsFlags; + + ImageAbort = function: BOOL; stdcall; + DrawImageAbort = ImageAbort; + GetThumbnailImageAbort = ImageAbort; + + Status = ( + Ok, + GenericError, + InvalidParameter, + OutOfMemory, + ObjectBusy, + InsufficientBuffer, + NotImplemented, + Win32Error, + WrongState, + Aborted, + FileNotFound, + ValueOverflow, + AccessDenied, + UnknownImageFormat, + FontFamilyNotFound, + FontStyleNotFound, + NotTrueTypeFont, + UnsupportedGdiplusVersion, + GdiplusNotInitialized, + PropertyNotFound, + PropertyNotSupported); + TStatus = Status; + + PSizeF = ^TSizeF; + TSizeF = packed record + Width : Single; + Height : Single; + end; + + PSize = ^TSize; + TSize = packed record + Width : Cardinal; + Height : Cardinal; + end; + + PPointF = ^TPointF; + TPointF = packed record + X : Single; + Y : Single; + end; + TPointFDynArray = array of TPointF; + TPointDynArray = array of TPoint; + + PRectF = ^TRectF; + TRectF = packed record + X : Single; + Y : Single; + Width : Single; + Height: Single; + end; + TRectFDynArray = array of TRectF; + TRectDynArray = array of TRect; + + TPathData = packed record + Count : Integer; + Points : PPointF; + Types : PBYTE; + end; + + PCharacterRange = ^TCharacterRange; + TCharacterRange = packed record + First : Integer; + Length : Integer; + end; + + DebugEventLevel = ( + DebugEventLevelFatal, + DebugEventLevelWarning); + TDebugEventLevel = DebugEventLevel; + + DebugEventProc = procedure(level: DebugEventLevel; message: PChar); stdcall; + NotificationHookProc = function(out token: ULONG): Status; stdcall; + NotificationUnhookProc = procedure(token: ULONG); stdcall; + + GdiplusStartupInput = packed record + GdiplusVersion : Cardinal; // Must be 1 + DebugEventCallback : DebugEventProc; // Ignored on free builds + SuppressBackgroundThread: BOOL; // FALSE unless you're prepared to call the hook/unhook functions properly + SuppressExternalCodecs : BOOL; // FALSE unless you want GDI+ only to use + end; // its internal image codecs. + TGdiplusStartupInput = GdiplusStartupInput; + PGdiplusStartupInput = ^TGdiplusStartupInput; + + GdiplusStartupOutput = packed record + NotificationHook : NotificationHookProc; + NotificationUnhook: NotificationUnhookProc; + end; + TGdiplusStartupOutput = GdiplusStartupOutput; + PGdiplusStartupOutput = ^TGdiplusStartupOutput; + + PARGB = ^ARGB; + ARGB = DWORD; + ARGB64 = Int64; + + PixelFormat = Integer; + TPixelFormat = PixelFormat; + + PaletteFlags = ( + PaletteFlagsHasAlpha = $0001, + PaletteFlagsGrayScale = $0002, + PaletteFlagsHalftone = $0004); + TPaletteFlags = PaletteFlags; + + ColorPalette = packed record + Flags : UINT ; // Palette flags + Count : UINT ; // Number of color entries + Entries: array [0..0] of ARGB ; // Palette color entries + end; + + TColorPalette = ColorPalette; + PColorPalette = ^TColorPalette; + + ColorMode = ( + ColorModeARGB32 = 0, + ColorModeARGB64 = 1); + TColorMode = ColorMode; + + ColorChannelFlags = ( + ColorChannelFlagsC = 0, + ColorChannelFlagsM, + ColorChannelFlagsY, + ColorChannelFlagsK, + ColorChannelFlagsLast); + TColorChannelFlags = ColorChannelFlags; + + PColor = ^TColor; + TColor = ARGB; + TColorDynArray = array of TColor; + RECTL = Windows.Trect; + SIZEL = Windows.TSize; + + ENHMETAHEADER3 = packed record + iType : DWORD; // Record type EMR_HEADER + nSize : DWORD; // Record size in bytes. This may be greater + // than the sizeof(ENHMETAHEADER). + rclBounds : RECTL; // Inclusive-inclusive bounds in device units + rclFrame : RECTL; // Inclusive-inclusive Picture Frame .01mm unit + dSignature : DWORD; // Signature. Must be ENHMETA_SIGNATURE. + nVersion : DWORD; // Version number + nBytes : DWORD; // Size of the metafile in bytes + nRecords : DWORD; // Number of records in the metafile + nHandles : WORD; // Number of handles in the handle table + // Handle index zero is reserved. + sReserved : WORD; // Reserved. Must be zero. + nDescription : DWORD; // Number of chars in the unicode desc string + // This is 0 if there is no description string + offDescription : DWORD; // Offset to the metafile description record. + // This is 0 if there is no description string + nPalEntries : DWORD; // Number of entries in the metafile palette. + szlDevice : SIZEL; // Size of the reference device in pels + szlMillimeters : SIZEL; // Size of the reference device in millimeters + end; + TENHMETAHEADER3 = ENHMETAHEADER3; + PENHMETAHEADER3 = ^TENHMETAHEADER3; + + PWMFRect16 = packed record + Left : INT16; + Top : INT16; + Right : INT16; + Bottom : INT16; + end; + TPWMFRect16 = PWMFRect16; + PPWMFRect16 = ^TPWMFRect16; + + WmfPlaceableFileHeader = packed record + Key : UINT32; // GDIP_WMF_PLACEABLEKEY + Hmf : INT16; // Metafile HANDLE number (always 0) + BoundingBox : PWMFRect16; // Coordinates in metafile units + Inch : INT16; // Number of metafile units per inch + Reserved : UINT32; // Reserved (always 0) + Checksum : INT16; // Checksum value for previous 10 WORDs + end; + TWmfPlaceableFileHeader = WmfPlaceableFileHeader; + PWmfPlaceableFileHeader = ^TWmfPlaceableFileHeader; + + TMetafileHeader = packed class + public + Type_ : TMetafileType; + Size : UINT; // Size of the metafile (in bytes) + Version : UINT; // EMF+, EMF, or WMF version + EmfPlusFlags : UINT; + DpiX : Single; + DpiY : Single; + X : Integer; // Bounds in device units + Y : Integer; + Width : Integer; + Height : Integer; + Header : record + case integer of + 0: (WmfHeader: TMETAHEADER;); + 1: (EmfHeader: TENHMETAHEADER3); + end; + EmfPlusHeaderSize : Integer; // size of the EMF+ header in file + LogicalDpiX : Integer; // Logical Dpi of reference Hdc + LogicalDpiY : Integer; // usually valid only for EMF+ + end; + + IImageBytes = Interface(IUnknown) + ['{025D1823-6C7D-447B-BBDB-A3CBC3DFA2FC}'] + function CountBytes(out pcb: UINT): HRESULT; stdcall; + function LockBytes(cb: UINT; ulOffset: ULONG; out ppvBytes: pointer): HRESULT; stdcall; + function UnlockBytes(pvBytes: pointer; cb: UINT; ulOffset: ULONG): HRESULT; stdcall; + end; + + ImageCodecInfo = packed record + Clsid : TGUID; + FormatID : TGUID; + CodecName : PWCHAR; + DllName : PWCHAR; + FormatDescription : PWCHAR; + FilenameExtension : PWCHAR; + MimeType : PWCHAR; + Flags : DWORD; + Version : DWORD; + SigCount : DWORD; + SigSize : DWORD; + SigPattern : PBYTE; + SigMask : PBYTE; + end; + TImageCodecInfo = ImageCodecInfo; + PImageCodecInfo = ^TImageCodecInfo; + + ImageCodecFlags = ( + ImageCodecFlagsEncoder = $00000001, + ImageCodecFlagsDecoder = $00000002, + ImageCodecFlagsSupportBitmap = $00000004, + ImageCodecFlagsSupportVector = $00000008, + ImageCodecFlagsSeekableEncode = $00000010, + ImageCodecFlagsBlockingDecode = $00000020, + ImageCodecFlagsBuiltin = $00010000, + ImageCodecFlagsSystem = $00020000, + ImageCodecFlagsUser = $00040000); + TImageCodecFlags = ImageCodecFlags; + + ImageLockMode = Integer; + TImageLockMode = ImageLockMode; + + BitmapData = packed record + Width : UINT; + Height : UINT; + Stride : Integer; + PixelFormat : PixelFormat; + Scan0 : Pointer; + Reserved : UINT; + end; + TBitmapData = BitmapData; + PBitmapData = ^TBitmapData; + + ImageFlags = ( + ImageFlagsNone = 0, + ImageFlagsScalable = $0001, + ImageFlagsHasAlpha = $0002, + ImageFlagsHasTranslucent = $0004, + ImageFlagsPartiallyScalable = $0008, + ImageFlagsColorSpaceRGB = $0010, + ImageFlagsColorSpaceCMYK = $0020, + ImageFlagsColorSpaceGRAY = $0040, + ImageFlagsColorSpaceYCBCR = $0080, + ImageFlagsColorSpaceYCCK = $0100, + ImageFlagsHasRealDPI = $1000, + ImageFlagsHasRealPixelSize = $2000, + ImageFlagsReadOnly = $00010000, + ImageFlagsCaching = $00020000); + TImageFlags = ImageFlags; + + RotateFlipType = ( + RotateNoneFlipNone = 0, + Rotate90FlipNone = 1, + Rotate180FlipNone = 2, + Rotate270FlipNone = 3, + RotateNoneFlipX = 4, + Rotate90FlipX = 5, + Rotate180FlipX = 6, + Rotate270FlipX = 7, + RotateNoneFlipY = Rotate180FlipX, + Rotate90FlipY = Rotate270FlipX, + Rotate180FlipY = RotateNoneFlipX, + Rotate270FlipY = Rotate90FlipX, + RotateNoneFlipXY = Rotate180FlipNone, + Rotate90FlipXY = Rotate270FlipNone, + Rotate180FlipXY = RotateNoneFlipNone, + Rotate270FlipXY = Rotate90FlipNone); + TRotateFlipType = RotateFlipType; + + EncoderParameter = packed record + Guid : TGUID; // GUID of the parameter + NumberOfValues : ULONG; // Number of the parameter values + Type_ : ULONG; // Value type, like ValueTypeLONG etc. + Value : Pointer; // A pointer to the parameter values + end; + TEncoderParameter = EncoderParameter; + PEncoderParameter = ^TEncoderParameter; + + EncoderParameters = packed record + Count : UINT; // Number of parameters in this structure + Parameter : array[0..0] of TEncoderParameter; // Parameter values + end; + TEncoderParameters = EncoderParameters; + PEncoderParameters = ^TEncoderParameters; + + PropertyItem = record // NOT PACKED !! + id : ULONG; // ID of this property + length : ULONG; // Length of the property value, in bytes + type_ : WORD; // Type of the value, as one of TAG_TYPE_XXX + value : Pointer; // property value + end; + TPropertyItem = PropertyItem; + PPropertyItem = ^TPropertyItem; + + ColorMatrix = packed array[0..4, 0..4] of Single; + TColorMatrix = ColorMatrix; + PColorMatrix = ^TColorMatrix; + + ColorMatrixFlags = ( + ColorMatrixFlagsDefault = 0, + ColorMatrixFlagsSkipGrays = 1, + ColorMatrixFlagsAltGray = 2); + TColorMatrixFlags = ColorMatrixFlags; + + ColorAdjustType = ( + ColorAdjustTypeDefault, + ColorAdjustTypeBitmap, + ColorAdjustTypeBrush, + ColorAdjustTypePen, + ColorAdjustTypeText, + ColorAdjustTypeCount, + ColorAdjustTypeAny); + TColorAdjustType = ColorAdjustType; + + ColorMap = packed record + oldColor: TColor; + newColor: TColor; + end; + TColorMap = ColorMap; + PColorMap = ^TColorMap; + + GpTexture = Pointer; + GpLineGradient = Pointer; + GpHatch = Pointer; + GpPen = Pointer; + GpCustomLineCap = Pointer; + GpAdjustableArrowCap = Pointer; + GpImage = Pointer; + GpBitmap = Pointer; + GpMetafile = Pointer; + GpImageAttributes = Pointer; + GpRegion = Pointer; + GpCachedBitmap = Pointer; + GpStatus = TStatus; + GpFillMode = TFillMode; + GpWrapMode = TWrapMode; + GpUnit = TUnit; + GpCoordinateSpace = TCoordinateSpace; + GpPointF = PPointF; + GpPoint = PPoint; + GpRectF = PRectF; + GpRect = PRect; + GpSizeF = PSizeF; + GpHatchStyle = THatchStyle; + GpDashStyle = TDashStyle; + GpLineCap = TLineCap; + GpDashCap = TDashCap; + GpPenAlignment = TPenAlignment; + GpLineJoin = TLineJoin; + GpPenType = TPenType; + LongIntType = TBrushType; + GpMatrixOrder = TMatrixOrder; + GpFlushIntention = TFlushIntention; + +const + WINGDIPDLL = 'gdiplus.dll'; + FlatnessDefault = 0.25; + + FontStyleRegular = Integer(0); + FontStyleBold = Integer(1); + FontStyleItalic = Integer(2); + FontStyleBoldItalic = Integer(3); + FontStyleUnderline = Integer(4); + FontStyleStrikeout = Integer(8); + + GDIP_EMFPLUS_RECORD_BASE = $00004000; + GDIP_WMF_RECORD_BASE = $00010000; + + StringFormatFlagsDirectionRightToLeft = $00000001; + StringFormatFlagsDirectionVertical = $00000002; + StringFormatFlagsNoFitBlackBox = $00000004; + StringFormatFlagsDisplayFormatControl = $00000020; + StringFormatFlagsNoFontFallback = $00000400; + StringFormatFlagsMeasureTrailingSpaces = $00000800; + StringFormatFlagsNoWrap = $00001000; + StringFormatFlagsLineLimit = $00002000; + StringFormatFlagsNoClip = $00004000; + + DriverStringOptionsCmapLookup = 1; + DriverStringOptionsVertical = 2; + DriverStringOptionsRealizedAdvance = 4; + DriverStringOptionsLimitSubpixel = 8; + + EncoderParameterValueTypeByte : Integer = 1; // 8-bit unsigned int + EncoderParameterValueTypeASCII : Integer = 2; // 8-bit byte containing one 7-bit ASCII code. NULL terminated. + EncoderParameterValueTypeShort : Integer = 3; // 16-bit unsigned int + EncoderParameterValueTypeLong : Integer = 4; // 32-bit unsigned int + EncoderParameterValueTypeRational : Integer = 5; // Two Longs. The first Long is the numerator, the second Long expresses the denomintor. + EncoderParameterValueTypeLongRange : Integer = 6; // Two longs which specify a range of integer values. The first Long specifies the lower end and the second one specifies the higher end. All values are inclusive at both ends + EncoderParameterValueTypeUndefined : Integer = 7; // 8-bit byte that can take any value depending on field definition + EncoderParameterValueTypeRationalRange : Integer = 8; // Two Rationals. The first Rational specifies the lower end and the second specifies the higher end. All values are inclusive at both ends + + FLT_MAX = 3.402823466e+38; // max value + FLT_MIN = 1.175494351e-38; // min positive value + REAL_MAX = FLT_MAX; + REAL_MIN = FLT_MIN; + REAL_TOLERANCE= (FLT_MIN * 100); + REAL_EPSILON = 1.192092896e-07; // FLT_EPSILON + + ALPHA_SHIFT = 24; + RED_SHIFT = 16; + GREEN_SHIFT = 8; + BLUE_SHIFT = 0; + ALPHA_MASK = (ARGB($ff) shl ALPHA_SHIFT); + + PixelFormatIndexed = $00010000; // Indexes into a palette + PixelFormatGDI = $00020000; // Is a GDI-supported format + PixelFormatAlpha = $00040000; // Has an alpha component + PixelFormatPAlpha = $00080000; // Pre-multiplied alpha + PixelFormatExtended = $00100000; // Extended color 16 bits/channel + PixelFormatCanonical = $00200000; + PixelFormatUndefined = 0; + PixelFormatDontCare = 0; + PixelFormat1bppIndexed = (1 or ( 1 shl 8) or PixelFormatIndexed or PixelFormatGDI); + PixelFormat4bppIndexed = (2 or ( 4 shl 8) or PixelFormatIndexed or PixelFormatGDI); + PixelFormat8bppIndexed = (3 or ( 8 shl 8) or PixelFormatIndexed or PixelFormatGDI); + PixelFormat16bppGrayScale = (4 or (16 shl 8) or PixelFormatExtended); + PixelFormat16bppRGB555 = (5 or (16 shl 8) or PixelFormatGDI); + PixelFormat16bppRGB565 = (6 or (16 shl 8) or PixelFormatGDI); + PixelFormat16bppARGB1555 = (7 or (16 shl 8) or PixelFormatAlpha or PixelFormatGDI); + PixelFormat24bppRGB = (8 or (24 shl 8) or PixelFormatGDI); + PixelFormat32bppRGB = (9 or (32 shl 8) or PixelFormatGDI); + PixelFormat32bppARGB = (10 or (32 shl 8) or PixelFormatAlpha or PixelFormatGDI or PixelFormatCanonical); + PixelFormat32bppPARGB = (11 or (32 shl 8) or PixelFormatAlpha or PixelFormatPAlpha or PixelFormatGDI); + PixelFormat48bppRGB = (12 or (48 shl 8) or PixelFormatExtended); + PixelFormat64bppARGB = (13 or (64 shl 8) or PixelFormatAlpha or PixelFormatCanonical or PixelFormatExtended); + PixelFormat64bppPARGB = (14 or (64 shl 8) or PixelFormatAlpha or PixelFormatPAlpha or PixelFormatExtended); + PixelFormatMax = 15; + + aclAliceBlue = $FFF0F8FF; + aclAntiqueWhite = $FFFAEBD7; + aclAqua = $FF00FFFF; + aclAquamarine = $FF7FFFD4; + aclAzure = $FFF0FFFF; + aclBeige = $FFF5F5DC; + aclBisque = $FFFFE4C4; + aclBlack = $FF000000; + aclBlanchedAlmond = $FFFFEBCD; + aclBlue = $FF0000FF; + aclBlueViolet = $FF8A2BE2; + aclBrown = $FFA52A2A; + aclBurlyWood = $FFDEB887; + aclCadetBlue = $FF5F9EA0; + aclChartreuse = $FF7FFF00; + aclChocolate = $FFD2691E; + aclCoral = $FFFF7F50; + aclCornflowerBlue = $FF6495ED; + aclCornsilk = $FFFFF8DC; + aclCrimson = $FFDC143C; + aclCyan = $FF00FFFF; + aclDarkBlue = $FF00008B; + aclDarkCyan = $FF008B8B; + aclDarkGoldenrod = $FFB8860B; + aclDarkGray = $FFA9A9A9; + aclDarkGreen = $FF006400; + aclDarkKhaki = $FFBDB76B; + aclDarkMagenta = $FF8B008B; + aclDarkOliveGreen = $FF556B2F; + aclDarkOrange = $FFFF8C00; + aclDarkOrchid = $FF9932CC; + aclDarkRed = $FF8B0000; + aclDarkSalmon = $FFE9967A; + aclDarkSeaGreen = $FF8FBC8B; + aclDarkSlateBlue = $FF483D8B; + aclDarkSlateGray = $FF2F4F4F; + aclDarkTurquoise = $FF00CED1; + aclDarkViolet = $FF9400D3; + aclDeepPink = $FFFF1493; + aclDeepSkyBlue = $FF00BFFF; + aclDimGray = $FF696969; + aclDodgerBlue = $FF1E90FF; + aclFirebrick = $FFB22222; + aclFloralWhite = $FFFFFAF0; + aclForestGreen = $FF228B22; + aclFuchsia = $FFFF00FF; + aclGainsboro = $FFDCDCDC; + aclGhostWhite = $FFF8F8FF; + aclGold = $FFFFD700; + aclGoldenrod = $FFDAA520; + aclGray = $FF808080; + aclGreen = $FF008000; + aclGreenYellow = $FFADFF2F; + aclHoneydew = $FFF0FFF0; + aclHotPink = $FFFF69B4; + aclIndianRed = $FFCD5C5C; + aclIndigo = $FF4B0082; + aclIvory = $FFFFFFF0; + aclKhaki = $FFF0E68C; + aclLavender = $FFE6E6FA; + aclLavenderBlush = $FFFFF0F5; + aclLawnGreen = $FF7CFC00; + aclLemonChiffon = $FFFFFACD; + aclLightBlue = $FFADD8E6; + aclLightCoral = $FFF08080; + aclLightCyan = $FFE0FFFF; + aclLightGoldenrodYellow = $FFFAFAD2; + aclLightGray = $FFD3D3D3; + aclLightGreen = $FF90EE90; + aclLightPink = $FFFFB6C1; + aclLightSalmon = $FFFFA07A; + aclLightSeaGreen = $FF20B2AA; + aclLightSkyBlue = $FF87CEFA; + aclLightSlateGray = $FF778899; + aclLightSteelBlue = $FFB0C4DE; + aclLightYellow = $FFFFFFE0; + aclLime = $FF00FF00; + aclLimeGreen = $FF32CD32; + aclLinen = $FFFAF0E6; + aclMagenta = $FFFF00FF; + aclMaroon = $FF800000; + aclMediumAquamarine = $FF66CDAA; + aclMediumBlue = $FF0000CD; + aclMediumOrchid = $FFBA55D3; + aclMediumPurple = $FF9370DB; + aclMediumSeaGreen = $FF3CB371; + aclMediumSlateBlue = $FF7B68EE; + aclMediumSpringGreen = $FF00FA9A; + aclMediumTurquoise = $FF48D1CC; + aclMediumVioletRed = $FFC71585; + aclMidnightBlue = $FF191970; + aclMintCream = $FFF5FFFA; + aclMistyRose = $FFFFE4E1; + aclMoccasin = $FFFFE4B5; + aclNavajoWhite = $FFFFDEAD; + aclNavy = $FF000080; + aclOldLace = $FFFDF5E6; + aclOlive = $FF808000; + aclOliveDrab = $FF6B8E23; + aclOrange = $FFFFA500; + aclOrangeRed = $FFFF4500; + aclOrchid = $FFDA70D6; + aclPaleGoldenrod = $FFEEE8AA; + aclPaleGreen = $FF98FB98; + aclPaleTurquoise = $FFAFEEEE; + aclPaleVioletRed = $FFDB7093; + aclPapayaWhip = $FFFFEFD5; + aclPeachPuff = $FFFFDAB9; + aclPeru = $FFCD853F; + aclPink = $FFFFC0CB; + aclPlum = $FFDDA0DD; + aclPowderBlue = $FFB0E0E6; + aclPurple = $FF800080; + aclRed = $FFFF0000; + aclRosyBrown = $FFBC8F8F; + aclRoyalBlue = $FF4169E1; + aclSaddleBrown = $FF8B4513; + aclSalmon = $FFFA8072; + aclSandyBrown = $FFF4A460; + aclSeaGreen = $FF2E8B57; + aclSeaShell = $FFFFF5EE; + aclSienna = $FFA0522D; + aclSilver = $FFC0C0C0; + aclSkyBlue = $FF87CEEB; + aclSlateBlue = $FF6A5ACD; + aclSlateGray = $FF708090; + aclSnow = $FFFFFAFA; + aclSpringGreen = $FF00FF7F; + aclSteelBlue = $FF4682B4; + aclTan = $FFD2B48C; + aclTeal = $FF008080; + aclThistle = $FFD8BFD8; + aclTomato = $FFFF6347; + aclTransparent = $00FFFFFF; + aclTurquoise = $FF40E0D0; + aclViolet = $FFEE82EE; + aclWheat = $FFF5DEB3; + aclWhite = $FFFFFFFF; + aclWhiteSmoke = $FFF5F5F5; + aclYellow = $FFFFFF00; + aclYellowGreen = $FF9ACD32; + + // Shift count and bit mask for A, R, G, B components + AlphaShift = 24; + RedShift = 16; + GreenShift = 8; + BlueShift = 0; + AlphaMask = $ff000000; + RedMask = $00ff0000; + GreenMask = $0000ff00; + BlueMask = $000000ff; + + GDIP_EMFPLUSFLAGS_DISPLAY = $00000001; + + ImageFormatUndefined : TGUID = '{b96b3ca9-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatMemoryBMP : TGUID = '{b96b3caa-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatBMP : TGUID = '{b96b3cab-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatEMF : TGUID = '{b96b3cac-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatWMF : TGUID = '{b96b3cad-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatJPEG : TGUID = '{b96b3cae-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatPNG : TGUID = '{b96b3caf-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatGIF : TGUID = '{b96b3cb0-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatTIFF : TGUID = '{b96b3cb1-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatEXIF : TGUID = '{b96b3cb2-0728-11d3-9d7b-0000f81ef32e}'; + ImageFormatIcon : TGUID = '{b96b3cb5-0728-11d3-9d7b-0000f81ef32e}'; + FrameDimensionTime : TGUID = '{6aedbd6d-3fb5-418a-83a6-7f45229dc872}'; + FrameDimensionResolution : TGUID = '{84236f7b-3bd3-428f-8dab-4ea1439ca315}'; + FrameDimensionPage : TGUID = '{7462dc86-6180-4c7e-8e3f-ee7333a7a483}'; + FormatIDImageInformation : TGUID = '{e5836cbe-5eef-4f1d-acde-ae4c43b608ce}'; + FormatIDJpegAppHeaders : TGUID = '{1c4afdcd-6177-43cf-abc7-5f51af39ee85}'; + EncoderCompression : TGUID = '{e09d739d-ccd4-44ee-8eba-3fbf8be4fc58}'; + EncoderColorDepth : TGUID = '{66087055-ad66-4c7c-9a18-38a2310b8337}'; + EncoderScanMethod : TGUID = '{3a4e2661-3109-4e56-8536-42c156e7dcfa}'; + EncoderVersion : TGUID = '{24d18c76-814a-41a4-bf53-1c219cccf797}'; + EncoderRenderMethod : TGUID = '{6d42c53a-229a-4825-8bb7-5c99e2b9a8b8}'; + EncoderQuality : TGUID = '{1d5be4b5-fa4a-452d-9cdd-5db35105e7eb}'; + EncoderTransformation : TGUID = '{8d0eb2d1-a58e-4ea8-aa14-108074b7b6f9}'; + EncoderLuminanceTable : TGUID = '{edb33bce-0266-4a77-b904-27216099e717}'; + EncoderChrominanceTable : TGUID = '{f2e455dc-09b3-4316-8260-676ada32481c}'; + EncoderSaveFlag : TGUID = '{292266fc-ac40-47bf-8cfc-a85b89a655de}'; + CodecIImageBytes : TGUID = '{025d1823-6c7d-447b-bbdb-a3cbc3dfa2fc}'; + + ImageLockModeRead = $0001; + ImageLockModeWrite = $0002; + ImageLockModeUserInputBuf = $0004; + + PropertyTagTypeByte : Integer = 1; + PropertyTagTypeASCII : Integer = 2; + PropertyTagTypeShort : Integer = 3; + PropertyTagTypeLong : Integer = 4; + PropertyTagTypeRational : Integer = 5; + PropertyTagTypeUndefined : Integer = 7; + PropertyTagTypeSLONG : Integer = 9; + PropertyTagTypeSRational : Integer = 10; + + PropertyTagExifIFD = $8769; + PropertyTagGpsIFD = $8825; + PropertyTagNewSubfileType = $00FE; + PropertyTagSubfileType = $00FF; + PropertyTagImageWidth = $0100; + PropertyTagImageHeight = $0101; + PropertyTagBitsPerSample = $0102; + PropertyTagCompression = $0103; + PropertyTagPhotometricInterp = $0106; + PropertyTagThreshHolding = $0107; + PropertyTagCellWidth = $0108; + PropertyTagCellHeight = $0109; + PropertyTagFillOrder = $010A; + PropertyTagDocumentName = $010D; + PropertyTagImageDescription = $010E; + PropertyTagEquipMake = $010F; + PropertyTagEquipModel = $0110; + PropertyTagStripOffsets = $0111; + PropertyTagOrientation = $0112; + PropertyTagSamplesPerPixel = $0115; + PropertyTagRowsPerStrip = $0116; + PropertyTagStripBytesCount = $0117; + PropertyTagMinSampleValue = $0118; + PropertyTagMaxSampleValue = $0119; + PropertyTagXResolution = $011A; // Image resolution in width direction + PropertyTagYResolution = $011B; // Image resolution in height direction + PropertyTagPlanarConfig = $011C; // Image data arrangement + PropertyTagPageName = $011D; + PropertyTagXPosition = $011E; + PropertyTagYPosition = $011F; + PropertyTagFreeOffset = $0120; + PropertyTagFreeByteCounts = $0121; + PropertyTagGrayResponseUnit = $0122; + PropertyTagGrayResponseCurve = $0123; + PropertyTagT4Option = $0124; + PropertyTagT6Option = $0125; + PropertyTagResolutionUnit = $0128; // Unit of X and Y resolution + PropertyTagPageNumber = $0129; + PropertyTagTransferFuncition = $012D; + PropertyTagSoftwareUsed = $0131; + PropertyTagDateTime = $0132; + PropertyTagArtist = $013B; + PropertyTagHostComputer = $013C; + PropertyTagPredictor = $013D; + PropertyTagWhitePoint = $013E; + PropertyTagPrimaryChromaticities = $013F; + PropertyTagColorMap = $0140; + PropertyTagHalftoneHints = $0141; + PropertyTagTileWidth = $0142; + PropertyTagTileLength = $0143; + PropertyTagTileOffset = $0144; + PropertyTagTileByteCounts = $0145; + PropertyTagInkSet = $014C; + PropertyTagInkNames = $014D; + PropertyTagNumberOfInks = $014E; + PropertyTagDotRange = $0150; + PropertyTagTargetPrinter = $0151; + PropertyTagExtraSamples = $0152; + PropertyTagSampleFormat = $0153; + PropertyTagSMinSampleValue = $0154; + PropertyTagSMaxSampleValue = $0155; + PropertyTagTransferRange = $0156; + PropertyTagJPEGProc = $0200; + PropertyTagJPEGInterFormat = $0201; + PropertyTagJPEGInterLength = $0202; + PropertyTagJPEGRestartInterval = $0203; + PropertyTagJPEGLosslessPredictors = $0205; + PropertyTagJPEGPointTransforms = $0206; + PropertyTagJPEGQTables = $0207; + PropertyTagJPEGDCTables = $0208; + PropertyTagJPEGACTables = $0209; + PropertyTagYCbCrCoefficients = $0211; + PropertyTagYCbCrSubsampling = $0212; + PropertyTagYCbCrPositioning = $0213; + PropertyTagREFBlackWhite = $0214; + PropertyTagICCProfile = $8773; // This TAG is defined by ICC + PropertyTagGamma = $0301; + PropertyTagICCProfileDescriptor = $0302; + PropertyTagSRGBRenderingIntent = $0303; + PropertyTagImageTitle = $0320; + PropertyTagCopyright = $8298; + PropertyTagResolutionXUnit = $5001; + PropertyTagResolutionYUnit = $5002; + PropertyTagResolutionXLengthUnit = $5003; + PropertyTagResolutionYLengthUnit = $5004; + PropertyTagPrintFlags = $5005; + PropertyTagPrintFlagsVersion = $5006; + PropertyTagPrintFlagsCrop = $5007; + PropertyTagPrintFlagsBleedWidth = $5008; + PropertyTagPrintFlagsBleedWidthScale = $5009; + PropertyTagHalftoneLPI = $500A; + PropertyTagHalftoneLPIUnit = $500B; + PropertyTagHalftoneDegree = $500C; + PropertyTagHalftoneShape = $500D; + PropertyTagHalftoneMisc = $500E; + PropertyTagHalftoneScreen = $500F; + PropertyTagJPEGQuality = $5010; + PropertyTagGridSize = $5011; + PropertyTagThumbnailFormat = $5012; // 1 = JPEG, 0 = RAW RGB + PropertyTagThumbnailWidth = $5013; + PropertyTagThumbnailHeight = $5014; + PropertyTagThumbnailColorDepth = $5015; + PropertyTagThumbnailPlanes = $5016; + PropertyTagThumbnailRawBytes = $5017; + PropertyTagThumbnailSize = $5018; + PropertyTagThumbnailCompressedSize = $5019; + PropertyTagColorTransferFunction = $501A; + PropertyTagThumbnailData = $501B; // RAW thumbnail bits in + PropertyTagThumbnailImageWidth = $5020; // Thumbnail width + PropertyTagThumbnailImageHeight = $5021; // Thumbnail height + PropertyTagThumbnailBitsPerSample = $5022; // Number of bits per + PropertyTagThumbnailCompression = $5023; // Compression Scheme + PropertyTagThumbnailPhotometricInterp = $5024; // Pixel composition + PropertyTagThumbnailImageDescription = $5025; // Image Tile + PropertyTagThumbnailEquipMake = $5026; // Manufacturer of Image Input equipment + PropertyTagThumbnailEquipModel = $5027; // Model of Image input equipment + PropertyTagThumbnailStripOffsets = $5028; // Image data location + PropertyTagThumbnailOrientation = $5029; // Orientation of image + PropertyTagThumbnailSamplesPerPixel = $502A; // Number of components + PropertyTagThumbnailRowsPerStrip = $502B; // Number of rows per strip + PropertyTagThumbnailStripBytesCount = $502C; // Bytes per compressed strip + PropertyTagThumbnailResolutionX = $502D; // Resolution in width direction + PropertyTagThumbnailResolutionY = $502E; // Resolution in height direction + PropertyTagThumbnailPlanarConfig = $502F; // Image data arrangement + PropertyTagThumbnailResolutionUnit = $5030; // Unit of X and Y Resolution + PropertyTagThumbnailTransferFunction = $5031; // Transfer function + PropertyTagThumbnailSoftwareUsed = $5032; // Software used + PropertyTagThumbnailDateTime = $5033; // File change date and time + PropertyTagThumbnailArtist = $5034; // Person who created the image + PropertyTagThumbnailWhitePoint = $5035; // White point chromaticity + PropertyTagThumbnailPrimaryChromaticities = $5036; // Chromaticities of primaries + PropertyTagThumbnailYCbCrCoefficients = $5037; // Color space transformation coefficients + PropertyTagThumbnailYCbCrSubsampling = $5038; // Subsampling ratio of Y to C + PropertyTagThumbnailYCbCrPositioning = $5039; // Y and C position + PropertyTagThumbnailRefBlackWhite = $503A; // Pair of black and white reference values + PropertyTagThumbnailCopyRight = $503B; // CopyRight holder + PropertyTagLuminanceTable = $5090; + PropertyTagChrominanceTable = $5091; + PropertyTagFrameDelay = $5100; + PropertyTagLoopCount = $5101; + PropertyTagPixelUnit = $5110; // Unit specifier for pixel/unit + PropertyTagPixelPerUnitX = $5111; // Pixels per unit in X + PropertyTagPixelPerUnitY = $5112; // Pixels per unit in Y + PropertyTagPaletteHistogram = $5113; // Palette histogram + PropertyTagExifExposureTime = $829A; + PropertyTagExifFNumber = $829D; + PropertyTagExifExposureProg = $8822; + PropertyTagExifSpectralSense = $8824; + PropertyTagExifISOSpeed = $8827; + PropertyTagExifOECF = $8828; + PropertyTagExifVer = $9000; + PropertyTagExifDTOrig = $9003; // Date & time of original + PropertyTagExifDTDigitized = $9004; // Date & time of digital data generation + PropertyTagExifCompConfig = $9101; + PropertyTagExifCompBPP = $9102; + PropertyTagExifShutterSpeed = $9201; + PropertyTagExifAperture = $9202; + PropertyTagExifBrightness = $9203; + PropertyTagExifExposureBias = $9204; + PropertyTagExifMaxAperture = $9205; + PropertyTagExifSubjectDist = $9206; + PropertyTagExifMeteringMode = $9207; + PropertyTagExifLightSource = $9208; + PropertyTagExifFlash = $9209; + PropertyTagExifFocalLength = $920A; + PropertyTagExifMakerNote = $927C; + PropertyTagExifUserComment = $9286; + PropertyTagExifDTSubsec = $9290; // Date & Time subseconds + PropertyTagExifDTOrigSS = $9291; // Date & Time original subseconds + PropertyTagExifDTDigSS = $9292; // Date & TIme digitized subseconds + PropertyTagExifFPXVer = $A000; + PropertyTagExifColorSpace = $A001; + PropertyTagExifPixXDim = $A002; + PropertyTagExifPixYDim = $A003; + PropertyTagExifRelatedWav = $A004; // related sound file + PropertyTagExifInterop = $A005; + PropertyTagExifFlashEnergy = $A20B; + PropertyTagExifSpatialFR = $A20C; // Spatial Frequency Response + PropertyTagExifFocalXRes = $A20E; // Focal Plane X Resolution + PropertyTagExifFocalYRes = $A20F; // Focal Plane Y Resolution + PropertyTagExifFocalResUnit = $A210; // Focal Plane Resolution Unit + PropertyTagExifSubjectLoc = $A214; + PropertyTagExifExposureIndex = $A215; + PropertyTagExifSensingMethod = $A217; + PropertyTagExifFileSource = $A300; + PropertyTagExifSceneType = $A301; + PropertyTagExifCfaPattern = $A302; + PropertyTagGpsVer = $0000; + PropertyTagGpsLatitudeRef = $0001; + PropertyTagGpsLatitude = $0002; + PropertyTagGpsLongitudeRef = $0003; + PropertyTagGpsLongitude = $0004; + PropertyTagGpsAltitudeRef = $0005; + PropertyTagGpsAltitude = $0006; + PropertyTagGpsGpsTime = $0007; + PropertyTagGpsGpsSatellites = $0008; + PropertyTagGpsGpsStatus = $0009; + PropertyTagGpsGpsMeasureMode = $00A; + PropertyTagGpsGpsDop = $000B; // Measurement precision + PropertyTagGpsSpeedRef = $000C; + PropertyTagGpsSpeed = $000D; + PropertyTagGpsTrackRef = $000E; + PropertyTagGpsTrack = $000F; + PropertyTagGpsImgDirRef = $0010; + PropertyTagGpsImgDir = $0011; + PropertyTagGpsMapDatum = $0012; + PropertyTagGpsDestLatRef = $0013; + PropertyTagGpsDestLat = $0014; + PropertyTagGpsDestLongRef = $0015; + PropertyTagGpsDestLong = $0016; + PropertyTagGpsDestBearRef = $0017; + PropertyTagGpsDestBear = $0018; + PropertyTagGpsDestDistRef = $0019; + PropertyTagGpsDestDist = $001A; + +type + EmfPlusRecordType = ( + WmfRecordTypeSetBkColor = (META_SETBKCOLOR or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetBkMode = (META_SETBKMODE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetMapMode = (META_SETMAPMODE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetROP2 = (META_SETROP2 or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetRelAbs = (META_SETRELABS or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetPolyFillMode = (META_SETPOLYFILLMODE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetStretchBltMode = (META_SETSTRETCHBLTMODE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetTextCharExtra = (META_SETTEXTCHAREXTRA or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetTextColor = (META_SETTEXTCOLOR or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetTextJustification = (META_SETTEXTJUSTIFICATION or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetWindowOrg = (META_SETWINDOWORG or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetWindowExt = (META_SETWINDOWEXT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetViewportOrg = (META_SETVIEWPORTORG or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetViewportExt = (META_SETVIEWPORTEXT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeOffsetWindowOrg = (META_OFFSETWINDOWORG or GDIP_WMF_RECORD_BASE), + WmfRecordTypeScaleWindowExt = (META_SCALEWINDOWEXT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeOffsetViewportOrg = (META_OFFSETVIEWPORTORG or GDIP_WMF_RECORD_BASE), + WmfRecordTypeScaleViewportExt = (META_SCALEVIEWPORTEXT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeLineTo = (META_LINETO or GDIP_WMF_RECORD_BASE), + WmfRecordTypeMoveTo = (META_MOVETO or GDIP_WMF_RECORD_BASE), + WmfRecordTypeExcludeClipRect = (META_EXCLUDECLIPRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeIntersectClipRect = (META_INTERSECTCLIPRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeArc = (META_ARC or GDIP_WMF_RECORD_BASE), + WmfRecordTypeEllipse = (META_ELLIPSE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeFloodFill = (META_FLOODFILL or GDIP_WMF_RECORD_BASE), + WmfRecordTypePie = (META_PIE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeRectangle = (META_RECTANGLE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeRoundRect = (META_ROUNDRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypePatBlt = (META_PATBLT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSaveDC = (META_SAVEDC or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetPixel = (META_SETPIXEL or GDIP_WMF_RECORD_BASE), + WmfRecordTypeOffsetClipRgn = (META_OFFSETCLIPRGN or GDIP_WMF_RECORD_BASE), + WmfRecordTypeTextOut = (META_TEXTOUT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeBitBlt = (META_BITBLT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeStretchBlt = (META_STRETCHBLT or GDIP_WMF_RECORD_BASE), + WmfRecordTypePolygon = (META_POLYGON or GDIP_WMF_RECORD_BASE), + WmfRecordTypePolyline = (META_POLYLINE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeEscape = (META_ESCAPE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeRestoreDC = (META_RESTOREDC or GDIP_WMF_RECORD_BASE), + WmfRecordTypeFillRegion = (META_FILLREGION or GDIP_WMF_RECORD_BASE), + WmfRecordTypeFrameRegion = (META_FRAMEREGION or GDIP_WMF_RECORD_BASE), + WmfRecordTypeInvertRegion = (META_INVERTREGION or GDIP_WMF_RECORD_BASE), + WmfRecordTypePaintRegion = (META_PAINTREGION or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSelectClipRegion = (META_SELECTCLIPREGION or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSelectObject = (META_SELECTOBJECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetTextAlign = (META_SETTEXTALIGN or GDIP_WMF_RECORD_BASE), + WmfRecordTypeDrawText = ($062F or GDIP_WMF_RECORD_BASE), // META_DRAWTEXT + WmfRecordTypeChord = (META_CHORD or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetMapperFlags = (META_SETMAPPERFLAGS or GDIP_WMF_RECORD_BASE), + WmfRecordTypeExtTextOut = (META_EXTTEXTOUT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetDIBToDev = (META_SETDIBTODEV or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSelectPalette = (META_SELECTPALETTE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeRealizePalette = (META_REALIZEPALETTE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeAnimatePalette = (META_ANIMATEPALETTE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetPalEntries = (META_SETPALENTRIES or GDIP_WMF_RECORD_BASE), + WmfRecordTypePolyPolygon = (META_POLYPOLYGON or GDIP_WMF_RECORD_BASE), + WmfRecordTypeResizePalette = (META_RESIZEPALETTE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeDIBBitBlt = (META_DIBBITBLT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeDIBStretchBlt = (META_DIBSTRETCHBLT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeDIBCreatePatternBrush = (META_DIBCREATEPATTERNBRUSH or GDIP_WMF_RECORD_BASE), + WmfRecordTypeStretchDIB = (META_STRETCHDIB or GDIP_WMF_RECORD_BASE), + WmfRecordTypeExtFloodFill = (META_EXTFLOODFILL or GDIP_WMF_RECORD_BASE), + WmfRecordTypeSetLayout = ($0149 or GDIP_WMF_RECORD_BASE), // META_SETLAYOUT + WmfRecordTypeResetDC = ($014C or GDIP_WMF_RECORD_BASE), // META_RESETDC + WmfRecordTypeStartDoc = ($014D or GDIP_WMF_RECORD_BASE), // META_STARTDOC + WmfRecordTypeStartPage = ($004F or GDIP_WMF_RECORD_BASE), // META_STARTPAGE + WmfRecordTypeEndPage = ($0050 or GDIP_WMF_RECORD_BASE), // META_ENDPAGE + WmfRecordTypeAbortDoc = ($0052 or GDIP_WMF_RECORD_BASE), // META_ABORTDOC + WmfRecordTypeEndDoc = ($005E or GDIP_WMF_RECORD_BASE), // META_ENDDOC + WmfRecordTypeDeleteObject = (META_DELETEOBJECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreatePalette = (META_CREATEPALETTE or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreateBrush = ($00F8 or GDIP_WMF_RECORD_BASE), // META_CREATEBRUSH + WmfRecordTypeCreatePatternBrush = (META_CREATEPATTERNBRUSH or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreatePenIndirect = (META_CREATEPENINDIRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreateFontIndirect = (META_CREATEFONTINDIRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreateBrushIndirect = (META_CREATEBRUSHINDIRECT or GDIP_WMF_RECORD_BASE), + WmfRecordTypeCreateBitmapIndirect = ($02FD or GDIP_WMF_RECORD_BASE), // META_CREATEBITMAPINDIRECT + WmfRecordTypeCreateBitmap = ($06FE or GDIP_WMF_RECORD_BASE), // META_CREATEBITMAP + WmfRecordTypeCreateRegion = (META_CREATEREGION or GDIP_WMF_RECORD_BASE), + EmfRecordTypeHeader = EMR_HEADER, + EmfRecordTypePolyBezier = EMR_POLYBEZIER, + EmfRecordTypePolygon = EMR_POLYGON, + EmfRecordTypePolyline = EMR_POLYLINE, + EmfRecordTypePolyBezierTo = EMR_POLYBEZIERTO, + EmfRecordTypePolyLineTo = EMR_POLYLINETO, + EmfRecordTypePolyPolyline = EMR_POLYPOLYLINE, + EmfRecordTypePolyPolygon = EMR_POLYPOLYGON, + EmfRecordTypeSetWindowExtEx = EMR_SETWINDOWEXTEX, + EmfRecordTypeSetWindowOrgEx = EMR_SETWINDOWORGEX, + EmfRecordTypeSetViewportExtEx = EMR_SETVIEWPORTEXTEX, + EmfRecordTypeSetViewportOrgEx = EMR_SETVIEWPORTORGEX, + EmfRecordTypeSetBrushOrgEx = EMR_SETBRUSHORGEX, + EmfRecordTypeEOF = EMR_EOF, + EmfRecordTypeSetPixelV = EMR_SETPIXELV, + EmfRecordTypeSetMapperFlags = EMR_SETMAPPERFLAGS, + EmfRecordTypeSetMapMode = EMR_SETMAPMODE, + EmfRecordTypeSetBkMode = EMR_SETBKMODE, + EmfRecordTypeSetPolyFillMode = EMR_SETPOLYFILLMODE, + EmfRecordTypeSetROP2 = EMR_SETROP2, + EmfRecordTypeSetStretchBltMode = EMR_SETSTRETCHBLTMODE, + EmfRecordTypeSetTextAlign = EMR_SETTEXTALIGN, + EmfRecordTypeSetColorAdjustment = EMR_SETCOLORADJUSTMENT, + EmfRecordTypeSetTextColor = EMR_SETTEXTCOLOR, + EmfRecordTypeSetBkColor = EMR_SETBKCOLOR, + EmfRecordTypeOffsetClipRgn = EMR_OFFSETCLIPRGN, + EmfRecordTypeMoveToEx = EMR_MOVETOEX, + EmfRecordTypeSetMetaRgn = EMR_SETMETARGN, + EmfRecordTypeExcludeClipRect = EMR_EXCLUDECLIPRECT, + EmfRecordTypeIntersectClipRect = EMR_INTERSECTCLIPRECT, + EmfRecordTypeScaleViewportExtEx = EMR_SCALEVIEWPORTEXTEX, + EmfRecordTypeScaleWindowExtEx = EMR_SCALEWINDOWEXTEX, + EmfRecordTypeSaveDC = EMR_SAVEDC, + EmfRecordTypeRestoreDC = EMR_RESTOREDC, + EmfRecordTypeSetWorldTransform = EMR_SETWORLDTRANSFORM, + EmfRecordTypeModifyWorldTransform = EMR_MODIFYWORLDTRANSFORM, + EmfRecordTypeSelectObject = EMR_SELECTOBJECT, + EmfRecordTypeCreatePen = EMR_CREATEPEN, + EmfRecordTypeCreateBrushIndirect = EMR_CREATEBRUSHINDIRECT, + EmfRecordTypeDeleteObject = EMR_DELETEOBJECT, + EmfRecordTypeAngleArc = EMR_ANGLEARC, + EmfRecordTypeEllipse = EMR_ELLIPSE, + EmfRecordTypeRectangle = EMR_RECTANGLE, + EmfRecordTypeRoundRect = EMR_ROUNDRECT, + EmfRecordTypeArc = EMR_ARC, + EmfRecordTypeChord = EMR_CHORD, + EmfRecordTypePie = EMR_PIE, + EmfRecordTypeSelectPalette = EMR_SELECTPALETTE, + EmfRecordTypeCreatePalette = EMR_CREATEPALETTE, + EmfRecordTypeSetPaletteEntries = EMR_SETPALETTEENTRIES, + EmfRecordTypeResizePalette = EMR_RESIZEPALETTE, + EmfRecordTypeRealizePalette = EMR_REALIZEPALETTE, + EmfRecordTypeExtFloodFill = EMR_EXTFLOODFILL, + EmfRecordTypeLineTo = EMR_LINETO, + EmfRecordTypeArcTo = EMR_ARCTO, + EmfRecordTypePolyDraw = EMR_POLYDRAW, + EmfRecordTypeSetArcDirection = EMR_SETARCDIRECTION, + EmfRecordTypeSetMiterLimit = EMR_SETMITERLIMIT, + EmfRecordTypeBeginPath = EMR_BEGINPATH, + EmfRecordTypeEndPath = EMR_ENDPATH, + EmfRecordTypeCloseFigure = EMR_CLOSEFIGURE, + EmfRecordTypeFillPath = EMR_FILLPATH, + EmfRecordTypeStrokeAndFillPath = EMR_STROKEANDFILLPATH, + EmfRecordTypeStrokePath = EMR_STROKEPATH, + EmfRecordTypeFlattenPath = EMR_FLATTENPATH, + EmfRecordTypeWidenPath = EMR_WIDENPATH, + EmfRecordTypeSelectClipPath = EMR_SELECTCLIPPATH, + EmfRecordTypeAbortPath = EMR_ABORTPATH, + EmfRecordTypeReserved_069 = 69, // Not Used + EmfRecordTypeGdiComment = EMR_GDICOMMENT, + EmfRecordTypeFillRgn = EMR_FILLRGN, + EmfRecordTypeFrameRgn = EMR_FRAMERGN, + EmfRecordTypeInvertRgn = EMR_INVERTRGN, + EmfRecordTypePaintRgn = EMR_PAINTRGN, + EmfRecordTypeExtSelectClipRgn = EMR_EXTSELECTCLIPRGN, + EmfRecordTypeBitBlt = EMR_BITBLT, + EmfRecordTypeStretchBlt = EMR_STRETCHBLT, + EmfRecordTypeMaskBlt = EMR_MASKBLT, + EmfRecordTypePlgBlt = EMR_PLGBLT, + EmfRecordTypeSetDIBitsToDevice = EMR_SETDIBITSTODEVICE, + EmfRecordTypeStretchDIBits = EMR_STRETCHDIBITS, + EmfRecordTypeExtCreateFontIndirect = EMR_EXTCREATEFONTINDIRECTW, + EmfRecordTypeExtTextOutA = EMR_EXTTEXTOUTA, + EmfRecordTypeExtTextOutW = EMR_EXTTEXTOUTW, + EmfRecordTypePolyBezier16 = EMR_POLYBEZIER16, + EmfRecordTypePolygon16 = EMR_POLYGON16, + EmfRecordTypePolyline16 = EMR_POLYLINE16, + EmfRecordTypePolyBezierTo16 = EMR_POLYBEZIERTO16, + EmfRecordTypePolylineTo16 = EMR_POLYLINETO16, + EmfRecordTypePolyPolyline16 = EMR_POLYPOLYLINE16, + EmfRecordTypePolyPolygon16 = EMR_POLYPOLYGON16, + EmfRecordTypePolyDraw16 = EMR_POLYDRAW16, + EmfRecordTypeCreateMonoBrush = EMR_CREATEMONOBRUSH, + EmfRecordTypeCreateDIBPatternBrushPt = EMR_CREATEDIBPATTERNBRUSHPT, + EmfRecordTypeExtCreatePen = EMR_EXTCREATEPEN, + EmfRecordTypePolyTextOutA = EMR_POLYTEXTOUTA, + EmfRecordTypePolyTextOutW = EMR_POLYTEXTOUTW, + EmfRecordTypeSetICMMode = 98, // EMR_SETICMMODE, + EmfRecordTypeCreateColorSpace = 99, // EMR_CREATECOLORSPACE, + EmfRecordTypeSetColorSpace = 100, // EMR_SETCOLORSPACE, + EmfRecordTypeDeleteColorSpace = 101, // EMR_DELETECOLORSPACE, + EmfRecordTypeGLSRecord = 102, // EMR_GLSRECORD, + EmfRecordTypeGLSBoundedRecord = 103, // EMR_GLSBOUNDEDRECORD, + EmfRecordTypePixelFormat = 104, // EMR_PIXELFORMAT, + EmfRecordTypeDrawEscape = 105, // EMR_RESERVED_105, + EmfRecordTypeExtEscape = 106, // EMR_RESERVED_106, + EmfRecordTypeStartDoc = 107, // EMR_RESERVED_107, + EmfRecordTypeSmallTextOut = 108, // EMR_RESERVED_108, + EmfRecordTypeForceUFIMapping = 109, // EMR_RESERVED_109, + EmfRecordTypeNamedEscape = 110, // EMR_RESERVED_110, + EmfRecordTypeColorCorrectPalette = 111, // EMR_COLORCORRECTPALETTE, + EmfRecordTypeSetICMProfileA = 112, // EMR_SETICMPROFILEA, + EmfRecordTypeSetICMProfileW = 113, // EMR_SETICMPROFILEW, + EmfRecordTypeAlphaBlend = 114, // EMR_ALPHABLEND, + EmfRecordTypeSetLayout = 115, // EMR_SETLAYOUT, + EmfRecordTypeTransparentBlt = 116, // EMR_TRANSPARENTBLT, + EmfRecordTypeReserved_117 = 117, // Not Used + EmfRecordTypeGradientFill = 118, // EMR_GRADIENTFILL, + EmfRecordTypeSetLinkedUFIs = 119, // EMR_RESERVED_119, + EmfRecordTypeSetTextJustification = 120, // EMR_RESERVED_120, + EmfRecordTypeColorMatchToTargetW = 121, // EMR_COLORMATCHTOTARGETW, + EmfRecordTypeCreateColorSpaceW = 122, // EMR_CREATECOLORSPACEW, + EmfRecordTypeMax = 122, + EmfRecordTypeMin = 1, + EmfPlusRecordTypeInvalid = GDIP_EMFPLUS_RECORD_BASE, + EmfPlusRecordTypeHeader, + EmfPlusRecordTypeEndOfFile, + EmfPlusRecordTypeComment, + EmfPlusRecordTypeGetDC, + EmfPlusRecordTypeMultiFormatStart, + EmfPlusRecordTypeMultiFormatSection, + EmfPlusRecordTypeMultiFormatEnd, + EmfPlusRecordTypeObject, + EmfPlusRecordTypeClear, + EmfPlusRecordTypeFillRects, + EmfPlusRecordTypeDrawRects, + EmfPlusRecordTypeFillPolygon, + EmfPlusRecordTypeDrawLines, + EmfPlusRecordTypeFillEllipse, + EmfPlusRecordTypeDrawEllipse, + EmfPlusRecordTypeFillPie, + EmfPlusRecordTypeDrawPie, + EmfPlusRecordTypeDrawArc, + EmfPlusRecordTypeFillRegion, + EmfPlusRecordTypeFillPath, + EmfPlusRecordTypeDrawPath, + EmfPlusRecordTypeFillClosedCurve, + EmfPlusRecordTypeDrawClosedCurve, + EmfPlusRecordTypeDrawCurve, + EmfPlusRecordTypeDrawBeziers, + EmfPlusRecordTypeDrawImage, + EmfPlusRecordTypeDrawImagePoints, + EmfPlusRecordTypeDrawString, + EmfPlusRecordTypeSetRenderingOrigin, + EmfPlusRecordTypeSetAntiAliasMode, + EmfPlusRecordTypeSetTextRenderingHint, + EmfPlusRecordTypeSetTextContrast, + EmfPlusRecordTypeSetInterpolationMode, + EmfPlusRecordTypeSetPixelOffsetMode, + EmfPlusRecordTypeSetCompositingMode, + EmfPlusRecordTypeSetCompositingQuality, + EmfPlusRecordTypeSave, + EmfPlusRecordTypeRestore, + EmfPlusRecordTypeBeginContainer, + EmfPlusRecordTypeBeginContainerNoParams, + EmfPlusRecordTypeEndContainer, + EmfPlusRecordTypeSetWorldTransform, + EmfPlusRecordTypeResetWorldTransform, + EmfPlusRecordTypeMultiplyWorldTransform, + EmfPlusRecordTypeTranslateWorldTransform, + EmfPlusRecordTypeScaleWorldTransform, + EmfPlusRecordTypeRotateWorldTransform, + EmfPlusRecordTypeSetPageTransform, + EmfPlusRecordTypeResetClip, + EmfPlusRecordTypeSetClipRect, + EmfPlusRecordTypeSetClipPath, + EmfPlusRecordTypeSetClipRegion, + EmfPlusRecordTypeOffsetClip, + EmfPlusRecordTypeDrawDriverString, + EmfPlusRecordTotal, + EmfPlusRecordTypeMax = EmfPlusRecordTotal-1, + EmfPlusRecordTypeMin = EmfPlusRecordTypeHeader); + TEmfPlusRecordType = EmfPlusRecordType; + EnumerateMetafileProc = function(recordType: EmfPlusRecordType; flags: UINT; dataSize: UINT; data: PBYTE; callbackData: pointer): BOOL; stdcall; + + function GdipAlloc(size: ULONG): pointer; stdcall;external WINGDIPDLL; + procedure GdipFree(ptr: pointer); stdcall;external WINGDIPDLL; + function GdiplusStartup(out token: THandle;const input: GdiplusStartupInput; output: PGdiplusStartupOutput): Status; stdcall;external WINGDIPDLL; + procedure GdiplusShutdown(token: ULONG); stdcall;external WINGDIPDLL; + function GdipCreatePath(brushMode: GPFILLMODE; out path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePath2(const v1,v2; v3: Integer; v4: GPFILLMODE; out path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePath2I(const v1,v2; v3: Integer; v4: GPFILLMODE; out path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipClonePath(path: THandle; out clonePath: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeletePath(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetPath(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPointCount(path: THandle; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathTypes(path: THandle; types: PBYTE; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathPoints(v1: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathPointsI(v1: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathFillMode(path: THandle; var fillmode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathFillMode(path: THandle; fillmode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathData(path: THandle; pathData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipStartPathFigure(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipClosePathFigure(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipClosePathFigures(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathMarker(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipClearPathMarkers(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipReversePath(path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathLastPoint(path: THandle; lastPoint: GPPOINTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathLine(path: THandle; x1, y1, x2, y2: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathLine2(path: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathArc(path: THandle; x, y, width, height, startAngle, sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathBezier(path: THandle; x1, y1, x2, y2, x3, y3, x4, y4: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathBeziers(path: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurve(path: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurve2(path: THandle; points: GPPOINTF; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurve3(path: THandle; points: GPPOINTF; count: Integer; offset: Integer; numberOfSegments: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathClosedCurve(path: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathClosedCurve2(path: THandle; points: GPPOINTF; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathRectangle(path: THandle; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathRectangles(path: THandle; rects: GPRECTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathEllipse(path: THandle; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathPie(path: THandle; x: Single; y: Single; width: Single; height: Single; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathPolygon(path: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathPath(path: THandle; addingPath: THandle; connect: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathString(path: THandle; string_: PWCHAR; length: Integer; family: THandle; style: Integer; emSize: Single; layoutRect: PRECTF; format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathStringI(path: THandle; string_: PWCHAR; length: Integer; family: THandle; style: Integer; emSize: Single; layoutRect: PRECT; format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathLineI(path: THandle; x1: Integer; y1: Integer; x2: Integer; y2: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathLine2I(path: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathArcI(path: THandle; x: Integer; y: Integer; width: Integer; height: Integer; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathBezierI(path: THandle; x1: Integer; y1: Integer; x2: Integer; y2: Integer; x3: Integer; y3: Integer; x4: Integer; y4: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathBeziersI(path: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurveI(path: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurve2I(path: THandle; points: GPPOINT; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathCurve3I(path: THandle; points: GPPOINT; count: Integer; offset: Integer; numberOfSegments: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathClosedCurveI(path: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathClosedCurve2I(path: THandle; points: GPPOINT; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathRectangleI(path: THandle; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathRectanglesI(path: THandle; rects: GPRECT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathEllipseI(path: THandle; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathPieI(path: THandle; x: Integer; y: Integer; width: Integer; height: Integer; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipAddPathPolygonI(path: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFlattenPath(path: THandle; matrix: THandle; flatness: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipWindingModeOutline(path: THandle; matrix: THandle; flatness: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipWidenPath(nativePath: THandle; pen: GPPEN; matrix: THandle; flatness: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipWarpPath(path: THandle; matrix: THandle; points: GPPOINTF; count: Integer; srcx: Single; srcy: Single; srcwidth: Single; srcheight: Single; warpMode: WARPMODE; flatness: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformPath(path: THandle; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathWorldBounds(path: THandle; bounds: GPRECTF; matrix: THandle; pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathWorldBoundsI(path: THandle; bounds: GPRECT; matrix: THandle; pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisiblePathPoint(path: THandle; x: Single; y: Single; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisiblePathPointI(path: THandle; x: Integer; y: Integer; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsOutlineVisiblePathPoint(path: THandle; x: Single; y: Single; pen: GPPEN; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsOutlineVisiblePathPointI(path: THandle; x: Integer; y: Integer; pen: GPPEN; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePathIter(out iterator: THandle; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeletePathIter(iterator: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterNextSubpath(iterator: THandle; var resultCount: Integer; var startIndex: Integer; var endIndex: Integer; out isClosed: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterNextSubpathPath(iterator: THandle; var resultCount: Integer; path: THandle; out isClosed: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterNextPathType(iterator: THandle; var resultCount: Integer; pathType: PBYTE; var startIndex: Integer; var endIndex: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterNextMarker(iterator: THandle; var resultCount: Integer; var startIndex: Integer; var endIndex: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterNextMarkerPath(iterator: THandle; var resultCount: Integer; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterGetCount(iterator: THandle; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterGetSubpathCount(iterator: THandle; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterIsValid(iterator: THandle; out valid: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterHasCurve(iterator: THandle; out hasCurve: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterRewind(iterator: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterEnumerate(iterator: THandle; var resultCount: Integer; points: GPPOINTF; types: PBYTE; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPathIterCopyData(iterator: THandle; var resultCount: Integer; points: GPPOINTF; types: PBYTE; startIndex: Integer; endIndex: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMatrix(out matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMatrix2(m11: Single; m12: Single; m21: Single; m22: Single; dx: Single; dy: Single; out matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMatrix3(rect: GPRECTF; dstplg: GPPOINTF; out matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMatrix3I(rect: GPRECT; dstplg: GPPOINT; out matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneMatrix(matrix: THandle; out cloneMatrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteMatrix(matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetMatrixElements(matrix: THandle; m11: Single; m12: Single; m21: Single; m22: Single; dx: Single; dy: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyMatrix(matrix: THandle; matrix2: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateMatrix(matrix: THandle; offsetX: Single; offsetY: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScaleMatrix(matrix: THandle; scaleX: Single; scaleY: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotateMatrix(matrix: THandle; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipShearMatrix(matrix: THandle; shearX: Single; shearY: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipInvertMatrix(matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformMatrixPoints(matrix: THandle; pts: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformMatrixPointsI(matrix: THandle; pts: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipVectorTransformMatrixPoints(matrix: THandle; pts: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipVectorTransformMatrixPointsI(matrix: THandle; pts: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMatrixElements(matrix: THandle; matrixOut: PSingle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsMatrixInvertible(matrix: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsMatrixIdentity(matrix: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsMatrixEqual(matrix: THandle; matrix2: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegion(out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegionRect(rect: GPRECTF; out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegionRectI(rect: GPRECT; out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegionPath(path: THandle; out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegionRgnData(regionData: PBYTE; size: Integer; out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateRegionHrgn(hRgn: HRGN; out region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneRegion(region: GPREGION; out cloneRegion: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteRegion(region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetInfinite(region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetEmpty(region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCombineRegionRect(region: GPREGION; rect: GPRECTF; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCombineRegionRectI(region: GPREGION; rect: GPRECT; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCombineRegionPath(region: GPREGION; path: THandle; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCombineRegionRegion(region: GPREGION; region2: GPREGION; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateRegion(region: GPREGION; dx: Single; dy: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateRegionI(region: GPREGION; dx: Integer; dy: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformRegion(region: GPREGION; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionBounds(region: GPREGION; graphics: THandle; rect: GPRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionBoundsI(region: GPREGION; graphics: THandle; rect: GPRECT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionHRgn(region: GPREGION; graphics: THandle; out hRgn: HRGN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsEmptyRegion(region: GPREGION; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsInfiniteRegion(region: GPREGION; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsEqualRegion(region: GPREGION; region2: GPREGION; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionDataSize(region: GPREGION; out bufferSize: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionData(region: GPREGION; buffer: PBYTE; bufferSize: UINT; sizeFilled: PUINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRegionPoint(region: GPREGION; x: Single; y: Single; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRegionPointI(region: GPREGION; x: Integer; y: Integer; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRegionRect(region: GPREGION; x: Single; y: Single; width: Single; height: Single; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRegionRectI(region: GPREGION; x: Integer; y: Integer; width: Integer; height: Integer; graphics: THandle; out result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionScansCount(region: GPREGION; out count: UINT; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionScans(region: GPREGION; rects: GPRECTF; out count: Integer; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRegionScansI(region: GPREGION; rects: GPRECT; out count: Integer; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneBrush(brush: THandle; out cloneBrush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteBrush(brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetBrushType(brush: THandle; out type_: LONGINTTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateHatchBrush(hatchstyle: Integer; forecol: ARGB; backcol: ARGB; out brush: GPHATCH): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetHatchStyle(brush: GPHATCH; out hatchstyle: GPHATCHSTYLE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetHatchForegroundColor(brush: GPHATCH; out forecol: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetHatchBackgroundColor(brush: GPHATCH; out backcol: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateTexture(image: GPIMAGE; wrapmode: GPWRAPMODE; var texture: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateTexture2(image: GPIMAGE; wrapmode: GPWRAPMODE; x: Single; y: Single; width: Single; height: Single; out texture: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateTextureIA(image: GPIMAGE; imageAttributes: GPIMAGEATTRIBUTES; x: Single; y: Single; width: Single; height: Single; out texture: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateTexture2I(image: GPIMAGE; wrapmode: GPWRAPMODE; x: Integer; y: Integer; width: Integer; height: Integer; out texture: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateTextureIAI(image: GPIMAGE; imageAttributes: GPIMAGEATTRIBUTES; x: Integer; y: Integer; width: Integer; height: Integer; out texture: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetTextureTransform(brush: GPTEXTURE; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetTextureTransform(brush: GPTEXTURE; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetTextureTransform(brush: GPTEXTURE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyTextureTransform(brush: GPTEXTURE; matrix: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateTextureTransform(brush: GPTEXTURE; dx: Single; dy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScaleTextureTransform(brush: GPTEXTURE; sx: Single; sy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotateTextureTransform(brush: GPTEXTURE; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetTextureWrapMode(brush: GPTEXTURE; wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetTextureWrapMode(brush: GPTEXTURE; var wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetTextureImage(brush: GPTEXTURE; out image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateSolidFill(color: ARGB; out brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetSolidFillColor(brush: THandle; color: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetSolidFillColor(brush: THandle; out color: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrush(point1: GPPOINTF; point2: GPPOINTF; color1: ARGB; color2: ARGB; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrushI(point1: GPPOINT; point2: GPPOINT; color1: ARGB; color2: ARGB; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrushFromRect(rect: GPRECTF; color1: ARGB; color2: ARGB; mode: LINEARGRADIENTMODE; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrushFromRectI(rect: GPRECT; color1: ARGB; color2: ARGB; mode: LINEARGRADIENTMODE; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrushFromRectWithAngle(rect: GPRECTF; color1: ARGB; color2: ARGB; angle: Single; isAngleScalable: Bool; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateLineBrushFromRectWithAngleI(rect: GPRECT; color1: ARGB; color2: ARGB; angle: Single; isAngleScalable: Bool; wrapMode: GPWRAPMODE; out lineGradient: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineColors(brush: GPLINEGRADIENT; color1: ARGB; color2: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineColors(brush: GPLINEGRADIENT; colors: PARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineRect(brush: GPLINEGRADIENT; rect: GPRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineRectI(brush: GPLINEGRADIENT; rect: GPRECT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineGammaCorrection(brush: GPLINEGRADIENT; useGammaCorrection: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineGammaCorrection(brush: GPLINEGRADIENT; out useGammaCorrection: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineBlendCount(brush: GPLINEGRADIENT; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineBlend(brush: GPLINEGRADIENT; blend: PSingle; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineBlend(brush: GPLINEGRADIENT; blend: PSingle; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLinePresetBlendCount(brush: GPLINEGRADIENT; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLinePresetBlend(brush: GPLINEGRADIENT; blend: PARGB; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLinePresetBlend(brush: GPLINEGRADIENT; blend: PARGB; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineSigmaBlend(brush: GPLINEGRADIENT; focus: Single; scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineLinearBlend(brush: GPLINEGRADIENT; focus: Single; scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineWrapMode(brush: GPLINEGRADIENT; wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineWrapMode(brush: GPLINEGRADIENT; out wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineTransform(brush: GPLINEGRADIENT; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetLineTransform(brush: GPLINEGRADIENT; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetLineTransform(brush: GPLINEGRADIENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyLineTransform(brush: GPLINEGRADIENT; matrix: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateLineTransform(brush: GPLINEGRADIENT; dx: Single; dy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScaleLineTransform(brush: GPLINEGRADIENT; sx: Single; sy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotateLineTransform(brush: GPLINEGRADIENT; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePathGradient(points: GPPOINTF; count: Integer; wrapMode: GPWRAPMODE; out polyGradient: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePathGradientI(points: GPPOINT; count: Integer; wrapMode: GPWRAPMODE; out polyGradient: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePathGradientFromPath(path: THandle; out polyGradient: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientCenterColor(brush: THandle; out colors: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientCenterColor(brush: THandle; colors: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientSurroundColorsWithCount(brush: THandle; color: PARGB; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientSurroundColorsWithCount(brush: THandle; color: PARGB; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientPath(brush: THandle; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientPath(brush: THandle; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientCenterPoint(brush: THandle; points: GPPOINTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientCenterPointI(brush: THandle; points: GPPOINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientCenterPoint(brush: THandle; points: GPPOINTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientCenterPointI(brush: THandle; points: GPPOINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientRect(brush: THandle; rect: GPRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientRectI(brush: THandle; rect: GPRECT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientPointCount(brush: THandle; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientSurroundColorCount(brush: THandle; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientGammaCorrection(brush: THandle; useGammaCorrection: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientGammaCorrection(brush: THandle; var useGammaCorrection: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientBlendCount(brush: THandle; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientBlend(brush: THandle; blend: PSingle; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientBlend(brush: THandle; blend: PSingle; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientPresetBlendCount(brush: THandle; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientPresetBlend(brush: THandle; blend: PARGB; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientPresetBlend(brush: THandle; blend: PARGB; positions: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientSigmaBlend(brush: THandle; focus: Single; scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientLinearBlend(brush: THandle; focus: Single; scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientWrapMode(brush: THandle; var wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientWrapMode(brush: THandle; wrapmode: GPWRAPMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientTransform(brush: THandle; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientTransform(brush: THandle; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetPathGradientTransform(brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyPathGradientTransform(brush: THandle; matrix: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslatePathGradientTransform(brush: THandle; dx: Single; dy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScalePathGradientTransform(brush: THandle; sx: Single; sy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotatePathGradientTransform(brush: THandle; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPathGradientFocusScales(brush: THandle; var xScale: Single; var yScale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPathGradientFocusScales(brush: THandle; xScale: Single; yScale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePen1(color: ARGB; width: Single; unit_: GPUNIT; out pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreatePen2(brush: THandle; width: Single; unit_: GPUNIT; out pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipClonePen(pen: GPPEN; out clonepen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeletePen(pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenWidth(pen: GPPEN; width: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenWidth(pen: GPPEN; out width: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenUnit(pen: GPPEN; unit_: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenUnit(pen: GPPEN; var unit_: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenLineCap197819(pen: GPPEN; startCap: GPLINECAP; endCap: GPLINECAP; dashCap: GPDASHCAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenStartCap(pen: GPPEN; startCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenEndCap(pen: GPPEN; endCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenDashCap197819(pen: GPPEN; dashCap: GPDASHCAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenStartCap(pen: GPPEN; out startCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenEndCap(pen: GPPEN; out endCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenDashCap197819(pen: GPPEN; out dashCap: GPDASHCAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenLineJoin(pen: GPPEN; lineJoin: GPLINEJOIN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenLineJoin(pen: GPPEN; var lineJoin: GPLINEJOIN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenCustomStartCap(pen: GPPEN; customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenCustomStartCap(pen: GPPEN; out customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenCustomEndCap(pen: GPPEN; customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenCustomEndCap(pen: GPPEN; out customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenMiterLimit(pen: GPPEN; miterLimit: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenMiterLimit(pen: GPPEN; out miterLimit: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenMode(pen: GPPEN; penMode: GPPENALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenMode(pen: GPPEN;var penMode: GPPENALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenTransform(pen: GPPEN; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenTransform(pen: GPPEN; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetPenTransform(pen: GPPEN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyPenTransform(pen: GPPEN; matrix: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslatePenTransform(pen: GPPEN; dx: Single; dy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScalePenTransform(pen: GPPEN; sx: Single; sy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotatePenTransform(pen: GPPEN; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenColor(pen: GPPEN; argb: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenColor(pen: GPPEN; out argb: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenBrushFill(pen: GPPEN; brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenBrushFill(pen: GPPEN; out brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenFillType(pen: GPPEN; out type_: GPPENTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenDashStyle(pen: GPPEN; out dashstyle: GPDASHSTYLE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenDashStyle(pen: GPPEN; dashstyle: GPDASHSTYLE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenDashOffset(pen: GPPEN; out offset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenDashOffset(pen: GPPEN; offset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenDashCount(pen: GPPEN; var count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenDashArray(pen: GPPEN; dash: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenDashArray(pen: GPPEN; dash: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenCompoundCount(pen: GPPEN; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPenCompoundArray(pen: GPPEN; dash: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPenCompoundArray(pen: GPPEN; dash: PSingle; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateCustomLineCap(fillPath: THandle; strokePath: THandle; baseCap: GPLINECAP; baseInset: Single; out customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteCustomLineCap(customCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneCustomLineCap(customCap: GPCUSTOMLINECAP; out clonedCap: GPCUSTOMLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapType(customCap: GPCUSTOMLINECAP; var capType: CUSTOMLINECAPTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCustomLineCapStrokeCaps(customCap: GPCUSTOMLINECAP; startCap: GPLINECAP; endCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapStrokeCaps(customCap: GPCUSTOMLINECAP; var startCap: GPLINECAP; var endCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCustomLineCapStrokeJoin(customCap: GPCUSTOMLINECAP; lineJoin: GPLINEJOIN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapStrokeJoin(customCap: GPCUSTOMLINECAP; var lineJoin: GPLINEJOIN): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCustomLineCapBaseCap(customCap: GPCUSTOMLINECAP; baseCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapBaseCap(customCap: GPCUSTOMLINECAP; var baseCap: GPLINECAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCustomLineCapBaseInset(customCap: GPCUSTOMLINECAP; inset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapBaseInset(customCap: GPCUSTOMLINECAP; var inset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCustomLineCapWidthScale(customCap: GPCUSTOMLINECAP; widthScale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCustomLineCapWidthScale(customCap: GPCUSTOMLINECAP; var widthScale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateAdjustableArrowCap(height: Single; width: Single; isFilled: Bool; out cap: GPADJUSTABLEARROWCAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetAdjustableArrowCapHeight(cap: GPADJUSTABLEARROWCAP; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetAdjustableArrowCapHeight(cap: GPADJUSTABLEARROWCAP; var height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetAdjustableArrowCapWidth(cap: GPADJUSTABLEARROWCAP; width: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetAdjustableArrowCapWidth(cap: GPADJUSTABLEARROWCAP; var width: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetAdjustableArrowCapMiddleInset(cap: GPADJUSTABLEARROWCAP; middleInset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetAdjustableArrowCapMiddleInset(cap: GPADJUSTABLEARROWCAP; var middleInset: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetAdjustableArrowCapFillState(cap: GPADJUSTABLEARROWCAP; fillState: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetAdjustableArrowCapFillState(cap: GPADJUSTABLEARROWCAP; var fillState: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipLoadImageFromStream(stream: ISTREAM; out image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipLoadImageFromFile(filename: PWCHAR; out image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipLoadImageFromStreamICM(stream: ISTREAM; out image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipLoadImageFromFileICM(filename: PWCHAR; out image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneImage(image: GPIMAGE; out cloneImage: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDisposeImage(image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSaveImageToFile(image: GPIMAGE; filename: PWCHAR; clsidEncoder: PGUID; encoderParams: PENCODERPARAMETERS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSaveImageToStream(image: GPIMAGE; stream: ISTREAM; clsidEncoder: PGUID; encoderParams: PENCODERPARAMETERS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSaveAdd(image: GPIMAGE; encoderParams: PENCODERPARAMETERS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSaveAddImage(image: GPIMAGE; newImage: GPIMAGE; encoderParams: PENCODERPARAMETERS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageGraphicsContext(image: GPIMAGE; out graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageBounds(image: GPIMAGE; srcRect: GPRECTF; var srcUnit: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageDimension(image: GPIMAGE; var width: Single; var height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageType(image: GPIMAGE; var type_: IMAGETYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageWidth(image: GPIMAGE; var width: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageHeight(image: GPIMAGE; var height: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageHorizontalResolution(image: GPIMAGE; var resolution: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageVerticalResolution(image: GPIMAGE; var resolution: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageFlags(image: GPIMAGE; var flags: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageRawFormat(image: GPIMAGE; format: PGUID): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImagePixelFormat(image: GPIMAGE; out format: TPIXELFORMAT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageThumbnail(image: GPIMAGE; thumbWidth: UINT; thumbHeight: UINT; out thumbImage: GPIMAGE; callback: GETTHUMBNAILIMAGEABORT; callbackData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetEncoderParameterListSize(image: GPIMAGE; clsidEncoder: PGUID; out size: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetEncoderParameterList(image: GPIMAGE; clsidEncoder: PGUID; size: UINT; buffer: PENCODERPARAMETERS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageGetFrameDimensionsCount(image: GPIMAGE; var count: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageGetFrameDimensionsList(image: GPIMAGE; dimensionIDs: PGUID; count: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageGetFrameCount(image: GPIMAGE; dimensionID: PGUID; var count: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageSelectActiveFrame(image: GPIMAGE; dimensionID: PGUID; frameIndex: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageRotateFlip(image: GPIMAGE; rfType: ROTATEFLIPTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImagePalette(image: GPIMAGE; palette: PCOLORPALETTE; size: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImagePalette(image: GPIMAGE; palette: PCOLORPALETTE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImagePaletteSize(image: GPIMAGE; var size: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPropertyCount(image: GPIMAGE; var numOfProperty: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPropertyIdList(image: GPIMAGE; numOfProperty: UINT; list: ULONG): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPropertyItemSize(image: GPIMAGE; propId: ULONG; var size: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPropertyItem(image: GPIMAGE; propId: ULONG; propSize: UINT; buffer: PPROPERTYITEM): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPropertySize(image: GPIMAGE; var totalBufferSize: UINT; var numProperties: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetAllPropertyItems(image: GPIMAGE; totalBufferSize: UINT; numProperties: UINT; allItems: PPROPERTYITEM): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRemovePropertyItem(image: GPIMAGE; propId: ULONG): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPropertyItem(image: GPIMAGE; item: PPROPERTYITEM): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipImageForceValidation(image: GPIMAGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromStream(stream: ISTREAM; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromFile(filename: PWCHAR; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromStreamICM(stream: ISTREAM; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromFileICM(filename: PWCHAR; var bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromScan0(width: Integer; height: Integer; stride: Integer; format: PIXELFORMAT; scan0: PBYTE; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromGraphics(width: Integer; height: Integer; target: THandle; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromGdiDib(gdiBitmapInfo: PBitmapInfo; gdiBitmapData: Pointer; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromHBITMAP(hbm: HBITMAP; hpal: HPALETTE; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateHBITMAPFromBitmap(bitmap: GPBITMAP; out hbmReturn: HBITMAP; background: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromHICON(hicon: HICON; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateHICONFromBitmap(bitmap: GPBITMAP; out hbmReturn: HICON): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateBitmapFromResource(hInstance: HMODULE; lpBitmapName: PWCHAR; out bitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneBitmapArea(x: Single; y: Single; width: Single; height: Single; format: PIXELFORMAT; srcBitmap: GPBITMAP; out dstBitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneBitmapAreaI(x: Integer; y: Integer; width: Integer; height: Integer; format: PIXELFORMAT; srcBitmap: GPBITMAP; out dstBitmap: GPBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBitmapLockBits(bitmap: GPBITMAP; rect: GPRECT; flags: UINT; format: PIXELFORMAT; lockedBitmapData: PBITMAPDATA): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBitmapUnlockBits(bitmap: GPBITMAP; lockedBitmapData: PBITMAPDATA): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBitmapGetPixel(bitmap: GPBITMAP; x: Integer; y: Integer; var color: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBitmapSetPixel(bitmap: GPBITMAP; x: Integer; y: Integer; color: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBitmapSetResolution(bitmap: GPBITMAP; xdpi: Single; ydpi: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateImageAttributes(out imageattr: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneImageAttributes(imageattr: GPIMAGEATTRIBUTES; out cloneImageattr: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDisposeImageAttributes(imageattr: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesToIdentity(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetImageAttributes(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesColorMatrix(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; colorMatrix: PCOLORMATRIX; grayMatrix: PCOLORMATRIX; flags: COLORMATRIXFLAGS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesThreshold(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; threshold: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesGamma(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; gamma: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesNoOp(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesColorKeys(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; colorLow: ARGB; colorHigh: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesOutputChannel(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; channelFlags: COLORCHANNELFLAGS): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesOutputChannelColorProfile(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; colorProfileFilename: PWCHAR): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesRemapTable(imageattr: GPIMAGEATTRIBUTES; type_: COLORADJUSTTYPE; enableFlag: Bool; mapSize: UINT; map: PCOLORMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesWrapMode(imageAttr: GPIMAGEATTRIBUTES; wrap: WRAPMODE; argb: ARGB; clamp: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetImageAttributesICMMode(imageAttr: GPIMAGEATTRIBUTES; on_: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageAttributesAdjustedPalette(imageAttr: GPIMAGEATTRIBUTES; colorPalette: PCOLORPALETTE; colorAdjustType: COLORADJUSTTYPE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFlush(graphics: THandle; intention: GPFLUSHINTENTION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFromHDC(hdc: HDC; out graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFromHDC2(hdc: HDC; hDevice: THandle; out graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFromHWND(hwnd: HWND; out graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFromHWNDICM(hwnd: HWND; out graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteGraphics(graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetDC(graphics: THandle; var hdc: HDC): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipReleaseDC(graphics: THandle; hdc: HDC): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCompositingMode(graphics: THandle; compositingMode: COMPOSITINGMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCompositingMode(graphics: THandle; var compositingMode: COMPOSITINGMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetRenderingOrigin(graphics: THandle; x: Integer; y: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetRenderingOrigin(graphics: THandle; var x: Integer; var y: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetCompositingQuality(graphics: THandle; compositingQuality: COMPOSITINGQUALITY): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCompositingQuality(graphics: THandle; var compositingQuality: COMPOSITINGQUALITY): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetSmoothingMode(graphics: THandle; smoothingMode: SMOOTHINGMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetSmoothingMode(graphics: THandle; var smoothingMode: SMOOTHINGMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPixelOffsetMode(graphics: THandle; pixelOffsetMode: PIXELOFFSETMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPixelOffsetMode(graphics: THandle; var pixelOffsetMode: PIXELOFFSETMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetTextRenderingHint(graphics: THandle; mode: TEXTRENDERINGHINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetTextRenderingHint(graphics: THandle; var mode: TEXTRENDERINGHINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetTextContrast(graphics: THandle; contrast: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetTextContrast(graphics: THandle; var contrast: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetInterpolationMode(graphics: THandle; interpolationMode: INTERPOLATIONMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetInterpolationMode(graphics: THandle; var interpolationMode: INTERPOLATIONMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetWorldTransform(graphics: THandle; matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetWorldTransform(graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMultiplyWorldTransform(graphics: THandle; matrix: THandle; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateWorldTransform(graphics: THandle; dx: Single; dy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipScaleWorldTransform(graphics: THandle; sx: Single; sy: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRotateWorldTransform(graphics: THandle; angle: Single; order: GPMATRIXORDER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetWorldTransform(graphics: THandle; out matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetPageTransform(graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPageUnit(graphics: THandle; var unit_: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetPageScale(graphics: THandle; var scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPageUnit(graphics: THandle; unit_: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetPageScale(graphics: THandle; scale: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetDpiX(graphics: THandle; var dpi: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetDpiY(graphics: THandle; var dpi: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformPoints(graphics: THandle; destSpace: GPCOORDINATESPACE; srcSpace: GPCOORDINATESPACE; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTransformPointsI(graphics: THandle; destSpace: GPCOORDINATESPACE; srcSpace: GPCOORDINATESPACE; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetNearestColor(graphics: THandle; argb: PARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateHalftonePalette: HPALETTE; stdcall;external WINGDIPDLL; + function GdipDrawLine(graphics: THandle; pen: GPPEN; x1: Single; y1: Single; x2: Single; y2: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawLineI(graphics: THandle; pen: GPPEN; x1: Integer; y1: Integer; x2: Integer; y2: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawLines(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawLinesI(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawArc(graphics: THandle; pen: GPPEN; x: Single; y: Single; width: Single; height: Single; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawArcI(graphics: THandle; pen: GPPEN; x: Integer; y: Integer; width: Integer; height: Integer; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawBezier(graphics: THandle; pen: GPPEN; x1: Single; y1: Single; x2: Single; y2: Single; x3: Single; y3: Single; x4: Single; y4: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawBezierI(graphics: THandle; pen: GPPEN; x1: Integer; y1: Integer; x2: Integer; y2: Integer; x3: Integer; y3: Integer; x4: Integer; y4: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawBeziers(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawBeziersI(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawRectangle(graphics: THandle; pen: GPPEN; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawRectangleI(graphics: THandle; pen: GPPEN; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawRectangles(graphics: THandle; pen: GPPEN; rects: GPRECTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawRectanglesI(graphics: THandle; pen: GPPEN; rects: GPRECT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawEllipse(graphics: THandle; pen: GPPEN; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawEllipseI(graphics: THandle; pen: GPPEN; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawPie(graphics: THandle; pen: GPPEN; x: Single; y: Single; width: Single; height: Single; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawPieI(graphics: THandle; pen: GPPEN; x: Integer; y: Integer; width: Integer; height: Integer; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawPolygon(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawPolygonI(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawPath(graphics: THandle; pen: GPPEN; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurve(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurveI(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurve2(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurve2I(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurve3(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer; offset: Integer; numberOfSegments: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCurve3I(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer; offset: Integer; numberOfSegments: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawClosedCurve(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawClosedCurveI(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawClosedCurve2(graphics: THandle; pen: GPPEN; points: GPPOINTF; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawClosedCurve2I(graphics: THandle; pen: GPPEN; points: GPPOINT; count: Integer; tension: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGraphicsClear(graphics: THandle; color: ARGB): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillRectangle(graphics: THandle; brush: THandle; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillRectangleI(graphics: THandle; brush: THandle; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillRectangles(graphics: THandle; brush: THandle; rects: GPRECTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillRectanglesI(graphics: THandle; brush: THandle; rects: GPRECT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPolygon(graphics: THandle; brush: THandle; points: GPPOINTF; count: Integer; fillMode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPolygonI(graphics: THandle; brush: THandle; points: GPPOINT; count: Integer; fillMode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPolygon2(graphics: THandle; brush: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPolygon2I(graphics: THandle; brush: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillEllipse(graphics: THandle; brush: THandle; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillEllipseI(graphics: THandle; brush: THandle; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPie(graphics: THandle; brush: THandle; x: Single; y: Single; width: Single; height: Single; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPieI(graphics: THandle; brush: THandle; x: Integer; y: Integer; width: Integer; height: Integer; startAngle: Single; sweepAngle: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillPath(graphics: THandle; brush: THandle; path: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillClosedCurve(graphics: THandle; brush: THandle; points: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillClosedCurveI(graphics: THandle; brush: THandle; points: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillClosedCurve2(graphics: THandle; brush: THandle; points: GPPOINTF; count: Integer; tension: Single; fillMode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillClosedCurve2I(graphics: THandle; brush: THandle; points: GPPOINT; count: Integer; tension: Single; fillMode: GPFILLMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFillRegion(graphics: THandle; brush: THandle; region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImage(graphics: THandle; image: GPIMAGE; x: Single; y: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImageI(graphics: THandle; image: GPIMAGE; x: Integer; y: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImageRect(graphics: THandle; image: GPIMAGE; x: Single; y: Single; width: Single; height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImageRectI(graphics: THandle; image: GPIMAGE; x: Integer; y: Integer; width: Integer; height: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePoints(graphics: THandle; image: GPIMAGE; dstpoints: GPPOINTF; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePointsI(graphics: THandle; image: GPIMAGE; dstpoints: GPPOINT; count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePointRect(graphics: THandle; image: GPIMAGE; x: Single; y: Single; srcx: Single; srcy: Single; srcwidth: Single; srcheight: Single; srcUnit: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePointRectI(graphics: THandle; image: GPIMAGE; x: Integer; y: Integer; srcx: Integer; srcy: Integer; srcwidth: Integer; srcheight: Integer; srcUnit: GPUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImageRectRect(graphics: THandle; image: GPIMAGE; dstx: Single; dsty: Single; dstwidth: Single; dstheight: Single; srcx: Single; srcy: Single; srcwidth: Single; srcheight: Single; srcUnit: GPUNIT; imageAttributes: GPIMAGEATTRIBUTES; callback: DRAWIMAGEABORT; callbackData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImageRectRectI(graphics: THandle; image: GPIMAGE; dstx: Integer; dsty: Integer; dstwidth: Integer; dstheight: Integer; srcx: Integer; srcy: Integer; srcwidth: Integer; srcheight: Integer; srcUnit: GPUNIT; imageAttributes: GPIMAGEATTRIBUTES; callback: DRAWIMAGEABORT; callbackData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePointsRect(graphics: THandle; image: GPIMAGE; points: GPPOINTF; count: Integer; srcx: Single; srcy: Single; srcwidth: Single; srcheight: Single; srcUnit: GPUNIT; imageAttributes: GPIMAGEATTRIBUTES; callback: DRAWIMAGEABORT; callbackData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawImagePointsRectI(graphics: THandle; image: GPIMAGE; points: GPPOINT; count: Integer; srcx: Integer; srcy: Integer; srcwidth: Integer; srcheight: Integer; srcUnit: GPUNIT; imageAttributes: GPIMAGEATTRIBUTES; callback: DRAWIMAGEABORT; callbackData: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestPoint(graphics: THandle; metafile: GPMETAFILE; destPoint: PPOINTF; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestPointI(graphics: THandle; metafile: GPMETAFILE; destPoint: PPOINT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestRect(graphics: THandle; metafile: GPMETAFILE; destRect: PRECTF; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestRectI(graphics: THandle; metafile: GPMETAFILE; destRect: PRECT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestPoints(graphics: THandle; metafile: GPMETAFILE; destPoints: PPOINTF; count: Integer; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileDestPointsI(graphics: THandle; metafile: GPMETAFILE; destPoints: PPOINT; count: Integer; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestPoint(graphics: THandle; metafile: GPMETAFILE; destPoint: PPOINTF; srcRect: PRECTF; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestPointI(graphics: THandle; metafile: GPMETAFILE; destPoint: PPOINT; srcRect: PRECT; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestRect(graphics: THandle; metafile: GPMETAFILE; destRect: PRECTF; srcRect: PRECTF; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestRectI(graphics: THandle; metafile: GPMETAFILE; destRect: PRECT; srcRect: PRECT; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestPoints(graphics: THandle; metafile: GPMETAFILE; destPoints: PPOINTF; count: Integer; srcRect: PRECTF; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEnumerateMetafileSrcRectDestPointsI(graphics: THandle; metafile: GPMETAFILE; destPoints: PPOINT; count: Integer; srcRect: PRECT; srcUnit: TUNIT; callback: ENUMERATEMETAFILEPROC; callbackData: Pointer; imageAttributes: GPIMAGEATTRIBUTES): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPlayMetafileRecord(metafile: GPMETAFILE; recordType: EMFPLUSRECORDTYPE; flags: UINT; dataSize: UINT; data: PBYTE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipGraphics(graphics: THandle; srcgraphics: THandle; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipRect(graphics: THandle; x: Single; y: Single; width: Single; height: Single; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipRectI(graphics: THandle; x: Integer; y: Integer; width: Integer; height: Integer; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipPath(graphics: THandle; path: THandle; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipRegion(graphics: THandle; region: GPREGION; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetClipHrgn(graphics: THandle; hRgn: HRGN; combineMode: COMBINEMODE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipResetClip(graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateClip(graphics: THandle; dx: Single; dy: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipTranslateClipI(graphics: THandle; dx: Integer; dy: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetClip(graphics: THandle; region: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetClipBounds(graphics: THandle; rect: GPRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetClipBoundsI(graphics: THandle; rect: GPRECT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsClipEmpty(graphics: THandle; result: PBool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetVisibleClipBounds(graphics: THandle; rect: GPRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetVisibleClipBoundsI(graphics: THandle; rect: GPRECT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleClipEmpty(graphics: THandle; var result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisiblePoint(graphics: THandle; x: Single; y: Single; var result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisiblePointI(graphics: THandle; x: Integer; y: Integer; var result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRect(graphics: THandle; x: Single; y: Single; width: Single; height: Single; var result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsVisibleRectI(graphics: THandle; x: Integer; y: Integer; width: Integer; height: Integer; var result: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSaveGraphics(graphics: THandle; var state: GRAPHICSSTATE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRestoreGraphics(graphics: THandle; state: GRAPHICSSTATE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBeginContainer(graphics: THandle; dstrect: GPRECTF; srcrect: GPRECTF; unit_: GPUNIT; var state: GRAPHICSCONTAINER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBeginContainerI(graphics: THandle; dstrect: GPRECT; srcrect: GPRECT; unit_: GPUNIT; var state: GRAPHICSCONTAINER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipBeginContainer2(graphics: THandle; var state: GRAPHICSCONTAINER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEndContainer(graphics: THandle; state: GRAPHICSCONTAINER): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileHeaderFromWmf(hWmf: HMETAFILE; wmfPlaceableFileHeader: PWMFPLACEABLEFILEHEADER; header: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileHeaderFromEmf(hEmf: HENHMETAFILE; header: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileHeaderFromFile(filename: PWCHAR; header: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileHeaderFromStream(stream: ISTREAM; header: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileHeaderFromMetafile(metafile: GPMETAFILE; header: Pointer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetHemfFromMetafile(metafile: GPMETAFILE; var hEmf: HENHMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateStreamOnFile(filename: PWCHAR; access: UINT; out stream: ISTREAM): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMetafileFromWmf(hWmf: HMETAFILE; deleteWmf: Bool; wmfPlaceableFileHeader: PWMFPLACEABLEFILEHEADER; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMetafileFromEmf(hEmf: HENHMETAFILE; deleteEmf: Bool; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMetafileFromFile(file_: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMetafileFromWmfFile(file_: PWCHAR; wmfPlaceableFileHeader: PWMFPLACEABLEFILEHEADER; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateMetafileFromStream(stream: ISTREAM; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafile(referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECTF; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafileI(referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECT; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafileFileName(fileName: PWCHAR; referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECTF; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafileFileNameI(fileName: PWCHAR; referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECT; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafileStream(stream: ISTREAM; referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECTF; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipRecordMetafileStreamI(stream: ISTREAM; referenceHdc: HDC; type_: EMFTYPE; frameRect: GPRECT; frameUnit: METAFILEFRAMEUNIT; description: PWCHAR; out metafile: GPMETAFILE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetMetafileDownLevelRasterizationLimit(metafile: GPMETAFILE; metafileRasterizationLimitDpi: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetMetafileDownLevelRasterizationLimit(metafile: GPMETAFILE; var metafileRasterizationLimitDpi: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageDecodersSize(out numDecoders: UINT; out size: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageDecoders(numDecoders: UINT; size: UINT; decoders: PIMAGECODECINFO): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageEncodersSize(out numEncoders: UINT; out size: UINT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetImageEncoders(numEncoders: UINT; size: UINT; encoders: PIMAGECODECINFO): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipComment(graphics: THandle; sizeData: UINT; data: PBYTE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFontFamilyFromName(name: PWCHAR; fontCollection: THandle; out FontFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteFontFamily(FontFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneFontFamily(FontFamily: THandle; out clonedFontFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetGenericFontFamilySansSerif(out nativeFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetGenericFontFamilySerif(out nativeFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetGenericFontFamilyMonospace(out nativeFamily: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFamilyName(family: THandle; name: PWideChar; language: LANGID): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipIsStyleAvailable(family: THandle; style: Integer; var IsStyleAvailable: Bool): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFontCollectionEnumerable(fontCollection: THandle; graphics: THandle; var numFound: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipFontCollectionEnumerate(fontCollection: THandle; numSought: Integer; gpfamilies: array of THandle; var numFound: Integer; graphics: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetEmHeight(family: THandle; style: Integer; out EmHeight: UINT16): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCellAscent(family: THandle; style: Integer; var CellAscent: UINT16): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetCellDescent(family: THandle; style: Integer; var CellDescent: UINT16): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLineSpacing(family: THandle; style: Integer; var LineSpacing: UINT16): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFontFromDC(hdc: HDC; out font: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFontFromLogfontA(hdc: HDC; logfont: PLOGFONTA; out font: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFontFromLogfontW(hdc: HDC; logfont: PLOGFONTW; out font: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateFont(fontFamily: THandle; emSize: Single; style: Integer; _unit: Unit_; out font: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneFont(font: THandle; out cloneFont: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteFont(font: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFamily(font: THandle; out family: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontStyle(font: THandle; var style: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontSize(font: THandle; var size: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontUnit(font: THandle; var unit_: TUNIT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontHeight(font: THandle; graphics: THandle; var height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontHeightGivenDPI(font: THandle; dpi: Single; var height: Single): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLogFontA(font: THandle; graphics: THandle; var logfontA: LOGFONTA): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetLogFontW(font: THandle; graphics: THandle; var logfontW: LOGFONTW): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipNewInstalledFontCollection(out fontCollection: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipNewPrivateFontCollection(out fontCollection: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeletePrivateFontCollection(out fontCollection: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontCollectionFamilyCount(fontCollection: THandle; var numFound: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetFontCollectionFamilyList(fontCollection: THandle; numSought: Integer; gpfamilies: THandle; var numFound: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPrivateAddFontFile(fontCollection: THandle; filename: PWCHAR): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipPrivateAddMemoryFont(fontCollection: THandle; memory: Pointer; length: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawString(graphics: THandle; string_: PWCHAR; length: Integer; font: THandle;var layoutRect: TRECTF; stringFormat: THandle; brush: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMeasureString(graphics: THandle; string_: PWCHAR; length: Integer; font: THandle; layoutRect: PRECTF; stringFormat: THandle; boundingBox: PRECTF; codepointsFitted: PInteger; linesFilled: PInteger): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMeasureCharacterRanges(graphics: THandle; string_: PWCHAR; length: Integer; font: THandle; layoutRect: PRECTF; stringFormat: THandle; regionCount: Integer; const regions: GPREGION): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawDriverString(graphics: THandle; const text: PUINT16; length: Integer; const font: THandle; const brush: THandle; const positions: PPOINTF; flags: Integer; const matrix: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipMeasureDriverString(graphics: THandle; text: PUINT16; length: Integer; font: THandle; positions: PPOINTF; flags: Integer; matrix: THandle; boundingBox: PRECTF): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateStringFormat(formatAttributes: Integer; language: LANGID; out format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipStringFormatGetGenericDefault(out format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipStringFormatGetGenericTypographic(out format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteStringFormat(format: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCloneStringFormat(format: THandle; out newFormat: THandle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatFlags(format: THandle; flags: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatFlags(format: THandle; out flags: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatAlign(format: THandle; align: STRINGALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatAlign(format: THandle; out align: STRINGALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatLineAlign(format: THandle; align: STRINGALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatLineAlign(format: THandle; out align: STRINGALIGNMENT): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatTrimming(format: THandle; trimming: STRINGTRIMMING): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatTrimming(format: THandle; out trimming: STRINGTRIMMING): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatHotkeyPrefix(format: THandle; hotkeyPrefix: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatHotkeyPrefix(format: THandle; out hotkeyPrefix: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatTabStops(format: THandle; firstTabOffset: Single; count: Integer; tabStops: PSingle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatTabStops(format: THandle; count: Integer; firstTabOffset: PSingle; tabStops: PSingle): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatTabStopCount(format: THandle; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatDigitSubstitution(format: THandle; language: LANGID; substitute: STRINGDIGITSUBSTITUTE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatDigitSubstitution(format: THandle; language: PUINT; substitute: PSTRINGDIGITSUBSTITUTE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipGetStringFormatMeasurableCharacterRangeCount(format: THandle; out count: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipSetStringFormatMeasurableCharacterRanges(format: THandle; rangeCount: Integer; ranges: PCHARACTERRANGE): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipCreateCachedBitmap(bitmap: GPBITMAP; graphics: THandle; out cachedBitmap: GPCACHEDBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDeleteCachedBitmap(cachedBitmap: GPCACHEDBITMAP): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipDrawCachedBitmap(graphics: THandle; cachedBitmap: GPCACHEDBITMAP; x: Integer; y: Integer): GPSTATUS; stdcall;external WINGDIPDLL; + function GdipEmfToWmfBits(hemf: HENHMETAFILE; cbData16: UINT; pData16: PBYTE; iMapMode: Integer; eFlags: Integer): UINT; stdcall;external WINGDIPDLL; + +implementation + +end. + + + diff --git a/IWFCam.dpr b/IWFCam.dpr new file mode 100644 index 0000000..7945f7c --- /dev/null +++ b/IWFCam.dpr @@ -0,0 +1,764 @@ +program DMScope; +{$R 1.res} + +//Exclude unnecessary code/data from output exe +{$IMAGEBASE $400000} //Base address (used in LoadIconW) +{$G-} //Imported data +{$R-} //Range checking +{$M-} //Run-Time Type Information +{$Y-} //Symbol declaration and cross-reference information +{$D-} //debug information +{$C-} //Asserts +{$L-} //Local Symbols +{$Q-} //Overflow checking +{$O+} //Optimization +{$J+} //Assignable typed const + +uses + Windows,Messages,MFAPI,WinSock,OpenGL,GDIPlus,ShellAPI,ShlObj,CommCtrl; + +function SetWindowThemeAttribute(hwnd,eAttribute: THandle;const pvAttribute;cbAttribute: Cardinal): LongInt;stdcall;external 'UxTheme.dll'; +function DwmGetWindowAttribute(hwnd: THandle;dwAttribute: Cardinal;out pvAttribute;cbAttribute: Cardinal):LongInt;stdcall;external 'dwmapi.dll'; +function wsprintfW(Output: PWideChar; Format: PWideChar): Cardinal;varargs;cdecl;external user32; +function WndProc(wnd,msg,wParam,lParam: THandle): LongInt;stdcall;forward; +function ToolBarProc(wnd,msg,wParam,lParam: THandle): LongInt;stdcall;forward; + +type + TITLEBARINFOEX=packed record + cbSize: Cardinal; + rcTitleBar: TRect; + rgstate: array[0..CCHILDREN_TITLEBAR] of Cardinal; + rgrect: array[0..CCHILDREN_TITLEBAR] of TRect; + end; + TMediaBuffer=class(TInterfacedObject,IMFMediaBuffer) + BackBuf,FrontBuf: PAnsiChar; + fBufSize: Cardinal; + constructor Create(Back,Front: pointer); + function Lock(ppbBuffer: ppointer;pcbMaxLength,pcbCurrentLength: PCardinal): LongInt;stdcall; + function Unlock: LongInt;stdcall; + function GetCurrentLength(pcbCurrentLength: PCardinal): LongInt;stdcall; + function SetCurrentLength(cbCurrentLength: Cardinal): LongInt;stdcall; + function GetMaxLength(pcbMaxLength: PCardinal): LongInt;stdcall; + end; + TTEGHeader =packed record + Signature: array[0..3] of AnsiChar; //0TEG or 1TEG or 2TEG + Cmd: word; + DataLen: word; + end; + PTEGHeader=^TTEGHeader; + TUDPInfo =packed record + Unknown: array[0..17] of byte; + UDPPort: word; + IPAddr: dword; + end; + TGetUDPInfo=packed record //1TEG cmd=$0C + TEGHeader: TTEGHeader; + Unknown1: dword; + Unknown2: dword; + UDPInfo: TUDPInfo; + CamName: array[0..26] of AnsiChar; + Unknown3: int64; + end; + PGetUDPInfo=^TGetUDPInfo; + TSetUDPInfo=packed record //1TEG cmd=$0D + TEGHeader: TTEGHeader; + UDPInfo: TUDPInfo; + Unknown2: byte; //default - 9 + PasswordHash: array[0..11] of AnsiChar; //default - "9e8040834b3a" + Align: array[0..2] of byte; + end; + TImageData =packed record //2TEG cmd=$03 + TEGHeader: TTEGHeader; + Unknown: int64; + FrameIndex: word; + PacketIndex: word; + ImageDataLen: dword; + MixedData: array[0..65535] of byte; //ImageData started from TegHeader.DataLen-16-ImageDataLen + end; + PImageData=^TImageData; + MIB_IPADDRROW=packed record + dwAddr: dword; + dwIndex: dword; + dwMask: dword; + dwBCastAddr: dword; + dwReasmSize: dword; + unused: dword; + end; + MIB_IPADDRTABLE=packed record + dwNumEntries: dword; + table: array[0..65535] of MIB_IPADDRROW; + end; + PMIB_IPADDRTABLE=^MIB_IPADDRTABLE; + +function GetBestInterface(dwDestAddr: dword;pdwBestIfIndex: pdword):dword;stdcall;external 'Iphlpapi.dll'; +function GetIpAddrTable(pIpAddrTable: PMIB_IPADDRTABLE;pdwSize: pdword;bOrder: boolean):dword;stdcall;external 'Iphlpapi.dll'; + +const + CamIPAddr =$010AA8C0; //192.168.10.1 + Width =640; + Height =480; + MaxBufSize =Width*Height*4; + FrameSize =int64(Width) shl 32+height; + FPS =int64(24) shl 32+1; + SampleDuration =10000000 div 24; + UPDATETEXTURE =WM_USER+1; + BTN_ROTATE =0; + BTN_SNAPSHOT =1; + BTN_RECORD =2; + BTN_BROWSE =3; + DMBTN_SNAPSHOT =256; + DMBTN_MINUS =1280; + DMBTN_PLUS =1024; + WM_GETTITLEBARINFOEX =$33F; + DWMWA_CAPTION_BUTTON_BOUNDS=5; + WTNCA_NODRAWICON =2; + //Pixel shader performs YUV2RGB conversion + FragmentShader: PAnsiChar='#version 430'#13#10+ + 'out vec4 Color;'+ + 'layout(location=0) uniform mat3 RotationMatrix;'+ + 'const mat4 yuv2rgb=mat4(1.164383, 0, 1.596027,-0.870787438,'+ + '1.164383,-0.391762,-0.812968, 0.529591063,'+ + '1.164383, 2.017232, 0,-1.081389938,'+ + ' 0, 0, 0, 1);'+ + 'layout(binding=0) uniform sampler2D Y;'+ + 'layout(binding=1) uniform sampler2D UV;'+ + 'void main(){'+ + 'vec2 texCoord=(vec3(gl_FragCoord.xy,1)*RotationMatrix).xy;'+ + 'Color=vec4(texture2D(Y,texCoord).r,texture2D(UV,texCoord).ga,1)*yuv2rgb;};'#0; + NoDrawIcon: int64=int64(WTNCA_NODRAWICON) shl 32+WTNCA_NODRAWICON; + GdipStartupInput: GdiplusStartupInput=(GdiplusVersion: 1); + //Curve coordinates fof GdipCreatePath2I (Toolbar icons) + ButtonPoints: array[0..33] of integer=(205,0,819,0,932,0,1024,92,1024,205,1024,819,1024,932,932,1024,819,1024,205,1024,92,1024,0,932,0,819,0,205,0,92,92,0,205,0); + ButtonPTypes: array[0..16] of byte=(0,1,3,3,3,1,3,3,3,1,3,3,3,1,3,3,3); + RotatePoints: array[0..95] of integer=(166,457,276,269,477,281,586,346,586,351,565,396,561,404,532,464,610,453,642,445,829,400,876,383,856,349,838,318,744,149,730,125,705,111,683,135,674,144,658,187,651,203,466,110,204,209,166,457,858,567,748,755,547,743,438,678,438,673,459,628,463,620,492,560,414,571,382,579,195,624,148,641,168,675,186,706,280,875,294,899,319,913,341,889,350,880,366,837,373,821,558,914,820,815,858,567); + RotatePTypes: array[0..47] of byte=(0,3,3,3,3,3,3,3,3,3,1,3,3,3,1,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,3,1,3,3,3,1,3,3,3,3,3,3,3,3,3); + SnapshotPoints: array[0..139]of integer=(512,458,576,458,627,509,627,573,627,637,576,689,512,689,448,689,397,637,397,573,397,509,448,458,512,458,512,379,619,379,706,466,706,573,706,680,619,767,512,767,405,767,318,680,318,573,318,466,405,379,512,379,799,391,816,391,829,405,829,422,829,438,816,452,799,452,782,452,768,438,768,422,768,405,782,391,799,391,194,327,279,327,320,327,329,282,341,251,351,228,362,205,388,205,636,205,662,205,673,228,683,251,695,282,704,327,745,327,830,327,865,327,893,356,893,391,893,756,893,791,865,819,830,819,194,819,159,819,131,791,131,756,131,391,131,356,159,327,194,327); + SnapshotPTypes: array[0..69] of byte=(0,3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,3,3,3,3,0,1,3,3,3,3,3,3,1,3,3,3,3,3,3,1,3,3,3,1,3,3,3,1,3,3,3,1,3,3,3); + RecordPoints: array[0..25] of integer=(512,277,642,277,747,382,747,512,747,642,642,747,512,747,382,747,277,642,277,512,277,382,382,277,512,277); + RecordPTypes: array[0..12] of byte=(0,3,3,3,3,3,3,3,3,3,3,3,3); + BrowsePoints: array[0..127]of integer=(148,788,148,802,158,814,173,814,770,814,781,814,791,806,794,795,875,462,879,447,867,432,851,432,282,432,271,432,262,438,258,448,148,788,148,235,148,687,229,439,237,416,258,401,282,401,788,401,788,316,788,303,777,291,764,291,417,291,343,291,381,210,338,210,173,210,159,210,148,221,148,235,118,788,118,235,118,204,143,180,173,180,338,180,411,180,374,261,417,261,764,261,794,261,819,286,819,316,819,401,849,401,874,397,894,422,905,436,909,453,905,469,823,802,817,827,795,844,770,844,173,844,141,844,117,818,118,788); + BrowsePTypes: array[0..63] of byte=(0,3,3,3,1,3,3,3,1,3,3,3,1,3,3,3,1,0,1,1,3,3,3,1,1,3,3,3,1,3,3,3,1,3,3,3,0,1,3,3,3,1,3,3,3,1,3,3,3,1,3,3,3,3,3,3,1,3,3,3,1,3,3,3); + //Parameters for Media Foundation intput - MJPEG, output - YUY2 + inputFilter: MFT_REGISTER_TYPE_INFO=(guidMajorType:'{73646976-0000-0010-8000-00AA00389B71}';guidSubtype:'{47504A4D-0000-0010-8000-00aa00389b71}'); + outputFilter: MFT_REGISTER_TYPE_INFO=(guidMajorType:'{73646976-0000-0010-8000-00AA00389B71}';guidSubtype:'{32595559-0000-0010-8000-00aa00389b71}'); + BlendFunc: BLENDFUNCTION=(SourceConstantAlpha: 255;AlphaFormat: AC_SRC_ALPHA); + AspectRatios: array[0..3] of single=(Width/Height,Height/Width,Width/Height,Height/Width); + pfd: TPixelFormatDescriptor=(nSize: sizeof(pfd); + nVersion: 1; + dwFlags: PFD_DRAW_TO_WINDOW+PFD_SUPPORT_OPENGL+PFD_DOUBLEBUFFER; + iPixelType: PFD_TYPE_RGBA; + cColorBits: 32; + cStencilBits: 1); +var + command: packed record //microscope command structure + signature: array[0..4] of AnsiChar; + cmd: word; + unknown: dword; + end=(signature:'JHCMD'); + icmp_request: packed record + _type: byte; + code: byte; + cksum: word; + id: word; + seq_num: word; + end=(_type: 8); //ICMPV4_ECHO_REQUEST_TYPE + RotationMatrix: array[0..3,0..8] of single; + Buttons: array[0..3] of record + ToolTipText: PWideChar; + IconPath: THandle; //GDI+ path-handle for drawing icon + Checkable: boolean; //Is button work as a checkbox or press button + State: byte; //State of checkbox-style button + end=((ToolTipText:'Rotate'#0),(ToolTipText:'Take a snapshot'#0),(ToolTipText:'Record video'#0;Checkable:true),(ToolTipText:'Choosing output directory')); + MJPGData1,MJPGData2,YUY2Data: array[0..MaxBufSize-1] of byte; + MFTBuffer: MFT_OUTPUT_DATA_BUFFER; + MJPGBuffer,YUY2Buffer: TMediaBuffer; + MFActivate: array of IMFActivate; + MFTransForm: IMFTransform; + MFSample: IMFSample; + MFSinkWriter: IMFSinkWriter; + MFMediaTypeH264, + MFMediaTypeYUY2, + MFMediaTypeMJPG: IMFMediaType; + ToolBarBuffer: pointer; //pointer to the toolbar bitmap + msg: tagMSG; + WSData: WSAData; + sock_addr: sockaddr_in=(sin_family:AF_INET); + i,StartRecTime,CurrentTime, + Rotation,HighLightedButton, + AllButtonsWidth: Cardinal; + MainWnd,DC,RC,YUY2toRGB,TempDC,gdip, + Graphics,ButtonPath,TransformMatrix, + ToolBar,font,family,format,ToolTip, + Sock: THandle; + TitleBarInfo: TITLEBARINFOEX=(cbSize: SIZEOF(TITLEBARINFOEX)); + ToolTipInfo: TOOLINFOW=(cbSize:sizeof(TOOLINFOW)); + ButtonBrushes,IconBrushes: array[0..1] of THandle; + textures: array[0..1] of Cardinal; + Scale,GdipScale: single; + Rect,ClientRect: TRECT; + BorderSize: TSize; + Color: RGBQUAD; + dwColor: Cardinal absolute Color; //Color as dword + OutputDir: array[0..4095] of WideChar; + BrowseInfo: TBrowseInfoW=(ulFlags:BIF_RETURNONLYFSDIRS); + Events: packed record + MJPEGDataReceived, + TextureLoaded, + SnapshotComplete, + VideoSampleComplete: THandle; + end; + bmi: BITMAPINFO=(bmiHeader:(biSize: sizeof(BITMAPINFOHEADER); + biPlanes: 1; + biBitCount: 32)); + +//Custom IMFMediaBuffer realization to access video data + constructor TMediaBuffer.Create(Back,Front: pointer); + begin + inherited Create; + BackBuf :=Back; + FrontBuf:=Front; + end; + function TMediaBuffer.Lock(ppbBuffer: ppointer;pcbMaxLength,pcbCurrentLength: PCardinal): LongInt;stdcall;//Just return pointer. Thread safety provided through events + begin + if pcbMaxLength<>nil then + pcbMaxLength^:=MaxBufSize; + if pcbCurrentLength<>nil then + pcbCurrentLength^:=fBufSize; + ppbBuffer^:=FrontBuf; + Result:=S_OK; + end; + function TMediaBuffer.Unlock: LongInt;stdcall; + begin + Result:=S_OK; + end; + function TMediaBuffer.GetCurrentLength(pcbCurrentLength: PCardinal): LongInt;stdcall; + begin + pcbCurrentLength^:=fBufSize; + Result:=S_OK; + end; + function TMediaBuffer.SetCurrentLength(cbCurrentLength: Cardinal): LongInt;stdcall; + begin + fBufSize:=cbCurrentLength; + Result:=S_OK; + end; + function TMediaBuffer.GetMaxLength(pcbMaxLength: PCardinal): LongInt;stdcall; + begin + pcbMaxLength^:=MaxBufSize; + Result:=S_OK; + end; + +//This thread is for decode received MJPG-data and also for encode output mp4-file +procedure TranscoderThread(lParam: Cardinal);stdcall; +var + status: Cardinal; +begin + repeat + WaitForSingleObject(Events.MJPEGDataReceived,INFINITE); + MFTransform.ProcessInput(0,MFSample,0); + MFTransform.ProcessOutput(0,1,MFTBuffer,status); + PostMessageW(MainWnd,UPDATETEXTURE,0,0); + if Buttons[BTN_RECORD].State>0 then + begin + ResetEvent(Events.VideoSampleComplete); + MFTBuffer.pSample.SetSampleTime((CurrentTime-StartRecTime)*10000); + MFSinkWriter.WriteSample(0,MFTBuffer.pSample); + SetEvent(Events.VideoSampleComplete); + end; + until false; +end; + +procedure DMReadDataThread(lpParam: Cardinal);stdcall; +label + start; + +const + GetUDPInfo: array[0..19] of byte=($31,$54,$45,$47,$0b,$00,$0c,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00); + SetUDPInfo: TSetUDPInfo=(TEGHeader:(Signature:'1TEG';Cmd:$0D;DataLen:40);Unknown2:9;PasswordHash:'9e8040834b3a'); + GetStream: array[0..35] of byte=($32,$54,$45,$47,$01,$00,$1c,$00,$01,$00,$00,$00,$00,$00,$00,$00,$01,$00,$00,$00,$08,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$00,$00,$00); +var + i,len: integer; + crc,LastHeartBeatTime: Cardinal; + ICMPSock: THandle; + buf: array[0..4096] of byte; + tmp: pointer; + IpTable: MIB_IPADDRTABLE absolute buf; +begin + WSAStartup($0202,WSData); + ICMPSock:=0; + icmp_request.id:=GetCurrentProcessId; + goto start; + with MJPGBuffer do + repeat + len:=recv(Sock,Buf,sizeof(Buf),0); + //Just reinitialize the sockets if some kind of socket error has been occurred. + //Then after successfully ping reinitialize the connection. + if len<1 then + begin + CloseSocket(Sock); + sock_addr.sin_port:=0; + start: + repeat + CloseSocket(ICMPSock); + ICMPSock:=socket(AF_INET,SOCK_RAW,IPPROTO_ICMP); + bind(ICMPSock,sock_addr,sizeof(sock_addr)); + i:=100; + setsockopt(ICMPSock,SOL_SOCKET,SO_RCVTIMEO,@i,4); + sock_addr.sin_addr.S_addr:=CamIPAddr; + icmp_request.seq_num:=GetTickCount; + crc:=Cardinal(icmp_request.id)+icmp_request.seq_num+8; + crc:=hiword(crc)+loword(crc); + icmp_request.cksum:=not(hiword(crc)+loword(crc)); + sendto(ICMPSock,icmp_request,sizeof(icmp_request),0,sock_addr,sizeof(sock_addr)); + until recv(ICMPSock,Buf,sizeof(Buf),0)>0; + + len:=sizeof(Buf); + GetIpAddrTable(@IpTable,@len,false); + GetBestInterface(CamIPAddr,@len); + for i:=0 to IpTable.dwNumEntries-1 do + with IpTable.table[i] do + if (dwIndex=len)and((dwAddr xor CamIPAddr) and dwMask=0) then + begin + SetUDPInfo.UDPInfo.IPAddr:=dwAddr; + sock_addr.sin_addr.S_addr:=dwAddr; + break; + end; + + sock_addr.sin_port:=swap(41773); + Sock:=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); + while bind(Sock,sock_addr,sizeof(sock_addr))<>0 do + inc(sock_addr.sin_port); + i:=500; + setsockopt(Sock,SOL_SOCKET,SO_RCVTIMEO,@i,4); + + SetUDPInfo.UDPInfo.UDPPort:=sock_addr.sin_port; + sock_addr.sin_addr.S_addr :=CamIPAddr; + sock_addr.sin_port :=swap(10104); + SendTo(Sock,GetUDPInfo,sizeof(GetUDPInfo),0,sock_addr,sizeof(sock_addr)); + Recv(Sock,buf,sizeof(Buf),0); + sock_addr.sin_port:=PGetUDPInfo(@Buf)^.UDPInfo.UDPPort; + SendTo(Sock,SetUDPInfo,sizeof(SetUDPInfo),0,sock_addr,sizeof(sock_addr)); + SendTo(Sock,GetStream,sizeof(GetStream),0,sock_addr,sizeof(sock_addr)); + + i:=0; + LastHeartBeatTime:=icmp_request.seq_num; + end + else if (PTEGHeader(@buf)^.Signature='2TEG')and(PTEGHeader(@buf)^.Cmd=3) then + with PImageData(@buf)^ do + begin + if (PacketIndex=0)and(pword(@BackBuf[0])^=$D8FF)and(pword(@BackBuf[i-2])^=$D9FF) then //Check SOI and EOI JPEG markers to ensure corect data received + begin + if WaitForMultipleObjects(3,@Events.TextureLoaded,true,0)=0 then //texture loaded and snapshot complete and video sample encoding complete + begin + fBufSize:=i; + tmp:=BackBuf; + BackBuf:=FrontBuf; + FrontBuf:=tmp; + SetEvent(Events.MJPEGDataReceived); + end; + i:=0; + end; + move(MixedData[TEGHeader.DataLen-16-ImageDataLen],BackBuf[i],ImageDataLen); + inc(i,ImageDataLen); + end; + + CurrentTime:=GetTickCount; + if CurrentTime-LastHeartBeatTime>5000 then //Send heartbeat cmd every 2 seconds + begin + SendTo(Sock,GetStream,sizeof(GetStream),0,sock_addr,sizeof(sock_addr)); + LastHeartBeatTime:=CurrentTime; + end; + until false; +end; + +function ToolBarProc(wnd,msg,wParam,lParam: THandle): LongInt;stdcall; +var + i,len: Cardinal; + f: THandle; + p: pointer; + layout: TRectF; + sysTime: SYSTEMTIME; +begin + result:=0; + case msg of + WM_MOUSEMOVE:begin + HighLightedButton:=loword(lParam) div (bmi.bmiHeader.biHeight+2); + if HighLightedButton0) then + GdipFillPath(graphics,ButtonBrushes[(State or wParam) xor 1],ButtonPath); + GdipFillPath(graphics,IconBrushes[State],IconPath); + GdipTranslateWorldTransform(graphics,bmi.bmiHeader.biHeight+2,0,MatrixOrderAppend); + end; + bmi.bmiHeader.biWidth:=Rect.Right-Rect.Left; + layout.x:=0; + layout.y:=0; + layout.Width:=(bmi.bmiHeader.biWidth-AllButtonsWidth)/GdipScale; + layout.Height:=bmi.bmiHeader.biHeight/GdipScale; + GdipDrawString(graphics,OutputDir,-1,font,layout,format,IconBrushes[0]); + GdipSetWorldTransform(graphics,TransformMatrix); + SetWindowPos(ToolBar,GetWindow(MainWnd,GW_HWNDPREV),Rect.Left,Rect.Top,0,0,SWP_NOACTIVATE+SWP_NOSIZE+SWP_NOREDRAW); + UpdateLayeredWindow(ToolBar,0,@Rect,@bmi.bmiHeader.biWidth,TempDC,@ClientRect,0,@BlendFunc,ULW_ALPHA); + ValidateRect(wnd,nil); + end; + WM_NCHITTEST:result:=HTCLIENT; + WM_LBUTTONUP:begin + case HighLightedButton of + BTN_ROTATE:begin + Rotation:=(Rotation+1) and 3; + WndProc(MainWnd,WM_SIZE,0,0); + end; + BTN_SNAPSHOT:begin + ResetEvent(Events.SnapshotComplete); + GetLocalTime(sysTime); + len:=lstrlenW(OutputDir); + with sysTime do + OutputDir[len+wsprintfW(@OutputDir[len],'%i-%i-%i_%i-%i-%i-%i.jpg',wYear,wMonth,wDay,wHour,wMinute,wSecond,wMilliseconds)]:=#0; + f:=CreateFileW(OutputDir,GENERIC_WRITE,0,nil,CREATE_ALWAYS,0,0); + OutputDir[len]:=#0; + if f<>INVALID_HANDLE_VALUE then + begin + WriteFile(f,MJPGBuffer.FrontBuf^,MJPGBuffer.fBufSize,i,nil); + CloseHandle(f); + end + else + MessageBoxW(MainWnd,'Can'#39' create jpeg-file.',nil,MB_OK); + SetEvent(Events.SnapshotComplete); + end; + BTN_RECORD:if Buttons[BTN_RECORD].State=0 then + begin + GetLocalTime(sysTime); + len:=lstrlenW(OutputDir); + with sysTime do + OutputDir[len+wsprintfW(@OutputDir[len],'%i-%i-%i_%i-%i-%i-%i.mp4',wYear,wMonth,wDay,wHour,wMinute,wSecond,wMilliseconds)]:=#0; + if MFCreateSinkWriterFromURL(OutputDir,nil,nil,MFSinkWriter)=0 then + begin + Buttons[2].State:=1; + StartRecTime:=CurrentTime; + MFTBuffer.pSample.SetSampleDuration(SampleDuration); + MFSinkWriter.AddStream(MFMediaTypeH264,i); + MFSinkWriter.SetInputMediaType(0,MFMediaTypeYUY2,nil); + MFTransform.ProcessMessage(MFT_MESSAGE_COMMAND_FLUSH,nil); + MFTransform.ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING,nil); + MFTransform.ProcessMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM,nil); + MFSinkWriter.BeginWriting; + end + else + MessageBoxW(MainWnd,'H264 encoder is not available. Can'#39't record video.',nil,MB_OK); + OutputDir[len]:=#0; + end + else + begin + WaitForSingleObject(Events.VideoSampleComplete,INFINITE); + Buttons[2].State:=0; + MFTransform.ProcessMessage(MFT_MESSAGE_NOTIFY_END_OF_STREAM,nil); + MFTransform.ProcessMessage(MFT_MESSAGE_COMMAND_DRAIN,nil); + MFSinkWriter.Finalize; + MFSinkWriter._Release; + pointer(MFSinkWriter):=nil; + end; + BTN_BROWSE:begin + p:=SHBrowseForFolderW(BrowseInfo); + if p<>nil then + begin + SHGetPathFromIDListW(p,OutputDir); + i:=lstrlenW(OutputDir); + if OutputDir[i-1]<>'\' then + OutputDir[i]:='\'; + OutputDir[i+1]:=#0; + end; + end; + else + defWindowProcW(wnd,WM_NCLBUTTONDOWN,wParam,lParam); + end; + ToolBarProc(wnd,WM_PAINT,0,0); + DefWindowProcW(wnd,msg,wParam,lParam); + end; + WM_LBUTTONDOWN:ToolBarProc(wnd,WM_PAINT,1,0); + else + result:=DefWindowProcW(wnd,msg,wParam,lParam); + end; +end; + +function WndProc(wnd,msg,wParam,lParam: THandle): LongInt;stdcall; +var + x: single; +begin + result:=0; + case msg of + WM_NCPAINT:begin + defWindowProcW(wnd,WM_NCPAINT,wParam,0); + ToolBarProc(ToolBar,WM_PAINT,0,0); + end; + WM_ERASEBKGND:; + UPDATETEXTURE:begin + glActiveTexture(GL_TEXTURE0); + glTexImage2D(GL_TEXTURE_2D,0,GL_RED,Width,Height,0,GL_RG,GL_UNSIGNED_BYTE,YUY2Data); //Y data + glActiveTexture(GL_TEXTURE1); + glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,Width shr 1,Height,0,GL_RGBA,GL_UNSIGNED_BYTE,YUY2Data); //UV data (actualy it YUYV) + SetEvent(Events.TextureLoaded); + WndProc(wnd,WM_PAINT,0,0); + end; + WM_PAINT:begin + glBegin(GL_TRIANGLE_STRIP); + glVertex2f(-1,1); + glVertex2f(1,1); + glVertex2f(-1,-1); + glVertex2f(1,-1); + glEnd; + SwapBuffers(DC); + ValidateRect(MainWnd,nil); + end; + WM_MOUSEMOVE:begin + HighLightedButton:=length(Buttons); + ToolBarProc(wnd,WM_PAINT,wParam and MK_LBUTTON,0); + end; + WM_SIZE:begin + GetWindowRect(wnd,Rect); + GetClientRect(wnd,ClientRect); + if ClientRect.Right=0 then //if window is minimized + exit; + RotationMatrix[0,0]:=Scale/ClientRect.Right; + RotationMatrix[0,4]:=-Scale/ClientRect.Bottom; + x:=(ClientRect.Right/ClientRect.Bottom)/AspectRatios[Rotation]; + if x>1 then + RotationMatrix[0,0]:=RotationMatrix[0,0]*x + else + RotationMatrix[0,4]:=RotationMatrix[0,4]/x; + RotationMatrix[3,3]:=RotationMatrix[0,0]; + RotationMatrix[1,3]:=-RotationMatrix[0,0]; + RotationMatrix[2,0]:=RotationMatrix[1,3]; + RotationMatrix[1,1]:=RotationMatrix[0,4]; + RotationMatrix[2,4]:=-RotationMatrix[0,4]; + RotationMatrix[3,1]:=RotationMatrix[2,4]; + RotationMatrix[0,2]:=(1-ClientRect.Right *RotationMatrix[0,0])*0.5; + RotationMatrix[3,5]:=RotationMatrix[0,2]; + RotationMatrix[1,5]:=1-RotationMatrix[0,2]; + RotationMatrix[2,2]:=RotationMatrix[1,5]; + RotationMatrix[0,5]:=(1-ClientRect.Bottom*RotationMatrix[0,4])*0.5; + RotationMatrix[1,2]:=RotationMatrix[0,5]; + RotationMatrix[2,5]:=1-RotationMatrix[0,5]; + RotationMatrix[3,2]:=RotationMatrix[2,5]; + glViewPort(0,0,ClientRect.Right,ClientRect.Bottom); + glUniformMatrix3fv(0,1,false,@RotationMatrix[Rotation]); + ToolBarProc(ToolBar,WM_PAINT,0,0); + end; + WM_GETMINMAXINFO:PMINMAXINFO(lParam)^.ptMinTrackSize.X:=AllButtonsWidth+1; + WM_MOVE:begin + GetWindowRect(wnd,Rect); + ToolBarProc(ToolBar,WM_PAINT,0,0); + end; + WM_CLOSE:begin + if Buttons[BTN_RECORD].State>0 then + begin + HighLightedButton:=BTN_RECORD; + ToolbarProc(ToolBar,WM_LBUTTONUP,0,0); + end; +// SendTo(CMDSock,StopCMD,sizeof(StopCMD),0,sock_addr,sizeof(sock_addr)); + ExitProcess(0); + end; + WM_NCLBUTTONDOWN, + WM_NCACTIVATE:begin + PostMessageW(ToolBar,WM_PAINT,0,0); + result:=DefWindowProcW(wnd,msg,wParam,lParam); + end; + else + result:=DefWindowProcW(wnd,msg,wParam,lParam); + end; +end; + +function _wglGetProcAddress(name: PAnsiChar): pointer; +begin + result:=wglGetProcAddress(name); + if result=nil then + begin + MessageBoxW(0,'Video card is not supported.',nil,MB_OK); + ExitProcess(0); + end; +end; + +begin + GetTempPathW(length(OutputDir),OutputDir); + + //Create MainWindow + MainWnd:=CreateWindowExW(WS_EX_DLGMODALFRAME,'STATIC',nil,WS_VISIBLE+WS_OVERLAPPEDWINDOW,0,0,Width,Height,0,0,0,nil); + SetWindowThemeAttribute(MainWnd,1,NoDrawIcon,sizeof(NoDrawIcon)); + + //Create caption-toolbar window + BorderSize.Width:=GetSystemMetrics(SM_CXSIZEFRAME); + if DwmGetWindowAttribute(MainWnd,DWMWA_CAPTION_BUTTON_BOUNDS,Rect,sizeof(Rect))=0 then //Check a condition for compatibility with Classic Windows theme + begin + SendMessageW(MainWnd,WM_SETICON,0,LoadIconW($400000,PWideChar(1))); + i:=Rect.Right-Rect.Left; + end + else + begin + BorderSize.Height:=GetSystemMetrics(SM_CYSIZEFRAME); + SendMessage(MainWnd,WM_GETTITLEBARINFOEX,0,LongInt(@TitleBarInfo)); + Rect:=TitleBarInfo.rcTitleBar; + i:=TitleBarInfo.rcTitleBar.Right-TitleBarInfo.rcTitleBar.Left-TitleBarInfo.rgrect[2].Left; + end; + bmi.bmiHeader.biHeight :=Rect.Bottom-Rect.Top; + bmi.bmiHeader.biWidth :=4096; + bmi.bmiHeader.biSizeImage:=bmi.bmiHeader.biWidth*bmi.bmiHeader.biHeight shl 2; + AllButtonsWidth:=i+(bmi.bmiHeader.biHeight+2)*length(Buttons)+BorderSize.Width; + ToolBar:=CreateWindowExW(WS_EX_LAYERED+WS_EX_NOACTIVATE,'STATIC',nil,WS_VISIBLE+WS_POPUP,0,0,bmi.bmiHeader.biWidth,bmi.bmiHeader.biHeight,0,0,0,nil); + BrowseInfo.hwndOwner:=ToolBar; + DC:=GetWindowDC(ToolBar); + TempDC:=CreateCompatibleDC(DC); + SelectObject(TempDC,CreateDIBSection(0,bmi,0,ToolBarBuffer,0,0)); + ReleaseDC(ToolBar,DC); + + //GDI+ initialization + DC:=GetWindowDC(MainWnd); + SetActiveWindow(MainWnd); + dwColor:=GetPixel(DC,10,10); //Get caption color + dwColor:=not -(((Color.rgbRed+Color.rgbGreen+Color.rgbBlue) div 3) shr 7); //Calculate contrast color for caption (black or white) + ReleaseDC(MainWnd,DC); + DC:=GetDC(MainWnd); + GdiplusStartup(gdip,GdipStartupInput,nil); + GdipCreateFromHDC(TempDC,Graphics); + GdipCreateMatrix(TransformMatrix); + GdipScale:=(bmi.bmiHeader.biHeight-BorderSize.Height)/1024; + GdipSetMatrixElements(TransformMatrix,GdipScale,0,0,GdipScale,BorderSize.Width,BorderSize.Height); + GdipSetSmoothingMode(graphics,SmoothingModeHighQuality); + GdipCreateStringFormat(StringFormatFlagsNoWrap,LANG_NEUTRAL,format); + GdipSetStringFormatLineAlign(format,StringAlignmentCenter); + GdipSetTextRenderingHint(graphics,TextRenderingHintAntiAliasGridFit); + GdipCreateFontFamilyFromName('Calibri',0,family); + GdipCreateFont(family,round(bmi.bmiHeader.biHeight*0.6)/GdipScale,0,UnitPixel,font); + Scale:=1; + GdipCreatePath2I(ButtonPoints,ButtonPTypes,length(ButtonPTypes),FillModeAlternate,ButtonPath); + GdipCreatePath2I(RotatePoints,RotatePTypes,length(RotatePTypes),FillModeAlternate,Buttons[0].IconPath); + GdipCreatePath2I(SnapshotPoints,SnapshotPTypes,length(SnapshotPTypes),FillModeAlternate,Buttons[1].IconPath); + GdipCreatePath2I(RecordPoints,RecordPTypes,length(RecordPTypes),FillModeAlternate,Buttons[2].IconPath); + GdipCreatePath2I(BrowsePoints,BrowsePTypes,length(BrowsePTypes),FillModeAlternate,Buttons[3].IconPath); + i:=Color.rgbBlue and 1; //Alpha values for pressed and released button colors in dark and light themes are oposite + Color.rgbReserved:=$90; + GdipCreateSolidFill(dwColor,ButtonBrushes[i]); + Color.rgbReserved:=$70; + GdipCreateSolidFill(dwColor,ButtonBrushes[i xor 1]); + Color.rgbReserved:=$FF; + GdipCreateSolidFill(dwColor,IconBrushes[0]); + GdipCreateSolidFill($FFFF0000,IconBrushes[1]); + + //OpenGL initialization + SetPixelFormat(DC,ChoosePixelFormat(DC,@pfd),@pfd); + RC:=wglCreateContext(DC); + wglMakeCurrent(DC,RC); + glActiveTexture :=_wglGetProcAddress('glActiveTexture'); + glUniformMatrix3fv:=_wglGetProcAddress('glUniformMatrix3fv'); + glLinkProgram :=_wglGetProcAddress('glLinkProgram'); + glShaderSource :=_wglGetProcAddress('glShaderSource'); + glUseProgram :=_wglGetProcAddress('glUseProgram'); + glAttachShader :=_wglGetProcAddress('glAttachShader'); + glCompileShader :=_wglGetProcAddress('glCompileShader'); + glCreateProgram :=_wglGetProcAddress('glCreateProgram'); + glCreateShader :=_wglGetProcAddress('glCreateShader'); + glDeleteShader :=_wglGetProcAddress('glDeleteShader'); + YUY2toRGB:=glCreateProgram; + i:=glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(i,1,@FragmentShader,nil); + glCompileShader(i); + glAttachShader(YUY2toRGB,i); + glDeleteShader(i); + glLinkProgram(YUY2toRGB); + glUseProgram(YUY2toRGB); + glEnable(GL_TEXTURE_2D); + glGenTextures(2,textures); + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D,textures[0]); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D,textures[1]); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_BORDER); + + //Initialize Media Foundation MJPEG to YUY2 decoder + CoInitializeEx(nil,COINIT_APARTMENTTHREADED+COINIT_DISABLE_OLE1DDE); + MFStartup(MF_VERSION,MFSTARTUP_FULL); + MFTEnumEx(MFT_CATEGORY_VIDEO_DECODER,MFT_ENUM_FLAG_SYNCMFT+MFT_ENUM_FLAG_LOCALMFT+MFT_ENUM_FLAG_SORTANDFILTER,inputFilter,outputFilter,MFActivate,i); + if i=0 then + begin + MessageBoxW(0,'MJPEG decoder is not available.',nil,MB_OK); + ExitProcess(0); + end; + MFCreateMediaType(MFMediaTypeH264); + MFMediaTypeH264.SetGUID(MF_MT_MAJOR_TYPE,MFMediaType_Video); + MFMediaTypeH264.SetGUID(MF_MT_SUBTYPE,MFVideoFormat_H264); + MFMediaTypeH264.SetUINT64(MF_MT_FRAME_RATE,FPS); + MFMediaTypeH264.SetUINT64(MF_MT_FRAME_SIZE,FrameSize); + MFMediaTypeH264.SetUINT32(MF_MT_INTERLACE_MODE,MFVideoInterlace_Progressive); + MFMediaTypeH264.SetUINT32(MF_MT_AVG_BITRATE,4*1024*1024); + MFCreateMediaType(MFMediaTypeYUY2); + MFMediaTypeYUY2.SetGUID(MF_MT_MAJOR_TYPE,MFMediaType_Video); + MFMediaTypeYUY2.SetGUID(MF_MT_SUBTYPE,MFVideoFormat_YUY2); + MFMediaTypeYUY2.SetUINT64(MF_MT_FRAME_SIZE,FrameSize); + MFCreateMediaType(MFMediaTypeMJPG); + MFMediaTypeMJPG.SetGUID(MF_MT_MAJOR_TYPE,MFMediaType_Video); + MFMediaTypeMJPG.SetGUID(MF_MT_SUBTYPE,MFVideoFormat_MJPG); + MFMediaTypeMJPG.SetUINT64(MF_MT_FRAME_SIZE,FrameSize); + MFActivate[0].ActivateObject(IMFTransform,@MFTransform); + MFActivate[0]._Release; + MFTransform.SetInputType(0,MFMediaTypeMJPG,0); + MFTransform.SetOutputType(0,MFMediaTypeYUY2,0); + MFCreateSample(MFSample); + MJPGBuffer:=TMediaBuffer.Create(@MJPGData1,@MJPGData2); + MFSample.AddBuffer(MJPGBuffer); + YUY2Buffer:=TMediaBuffer.Create(@YUY2Data,@YUY2Data); + MFCreateSample(MFTBuffer.pSample); + MFTBuffer.pSample.AddBuffer(YUY2Buffer); + + //Events for threads synchronization + Events.MJPEGDataReceived :=CreateEvent(nil,false,false,nil); + Events.TextureLoaded :=CreateEvent(nil,false,true,nil); + Events.SnapshotComplete :=CreateEvent(nil,true,true,nil); + Events.VideoSampleComplete:=CreateEvent(nil,true,true,nil); + CreateThread(nil,0,@DMReadDataThread,nil,0,PCardinal(0)^); + CreateThread(nil,0,@TranscoderThread,nil,0,PCardinal(0)^); + + SetWindowLongW(MainWnd,GWL_WNDPROC,LongInt(@WndProc)); + SetWindowLongW(ToolBar,GWL_WNDPROC,LongInt(@ToolBarProc)); + + //Place window in the center of the screen and adjust window size to fit the video + GetWindowRect(MainWnd,Rect); + GetClientRect(MainWnd,ClientRect); + dec(Rect.Right,ClientRect.Right-Width); + dec(Rect.Bottom,ClientRect.Bottom-Height); + Rect.Left:=(GetSystemMetrics(SM_CXSCREEN)-Rect.Right) shr 1; + Rect.Top :=(GetSystemMetrics(SM_CYSCREEN)-Rect.Bottom) shr 1; + MoveWindow(MainWnd,Rect.Left,Rect.Top,Rect.Right,Rect.Bottom,true); + + //Tooltips for toolbar + ToolTip:=CreateWindowExW(WS_EX_TOPMOST,TOOLTIPS_CLASS,nil,WS_POPUP+TTS_NOPREFIX+TTS_ALWAYSTIP,0,0,0,0,ToolBar,0,0,nil); + ToolTipInfo.hwnd:=ToolBar; + ToolTipInfo.rect:=ClientRect; + SendMessageW(ToolTip,TTM_ADDTOOLW,0,LongInt(@ToolTipInfo)); + + repeat + GetMessageW(msg,0,0,0); + TranslateMessage(msg); + DispatchMessageW(msg); + if msg.hwnd=ToolBar then + SendMessageW(Tooltip,TTM_RELAYEVENT,0,LongInt(@msg)); + until false; +end. diff --git a/MFAPI.pas b/MFAPI.pas new file mode 100644 index 0000000..85b12ad --- /dev/null +++ b/MFAPI.pas @@ -0,0 +1,961 @@ +unit MFAPI; + +{$W-} +interface + +uses Windows; + +const + mfdll ='MF.DLL'; + mfplat='MFPLAT.DLL'; + mfreadwrite='MFREADWRITE.DLL'; + ole32 ='OLE32.DLL'; + + E_NOTIMPL = $80004001; + S_OK = 0; + + COINIT_MULTITHREADED = 0; // OLE calls objects on any thread. + COINIT_APARTMENTTHREADED = 2; // Apartment model + COINIT_DISABLE_OLE1DDE = 4; // Dont use DDE for Ole1 support. + COINIT_SPEED_OVER_MEMORY = 8; // Trade memory for speed. + + MF_VERSION = $10070; + + MFSTARTUP_NOSOCKET =1; + MFSTARTUP_LITE =MFSTARTUP_NOSOCKET; + MFSTARTUP_FULL =0; + + MF_E_ATTRIBUTENOTFOUND =$C00D36E6; + + MF_TRANSCODE_ADJUST_PROFILE_DEFAULT =0; + MF_TRANSCODE_ADJUST_PROFILE_USE_SOURCE_ATTRIBUTES =1; + + MF_RESOLUTION_MEDIASOURCE = $1; + MF_RESOLUTION_BYTESTREAM = $2; + MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE = $10; + MF_RESOLUTION_KEEP_BYTE_STREAM_ALIVE_ON_FAIL = $20; + MF_RESOLUTION_DISABLE_LOCAL_PLUGINS = $40; + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_APPROVED_ONLY = $80; + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY = $100; + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY_EDGEMODE = $200; + MF_RESOLUTION_ENABLE_STORE_PLUGINS = $400; + MF_RESOLUTION_READ = $10000; + MF_RESOLUTION_WRITE = $20000; + + MFBYTESTREAM_IS_READABLE = $00000001; + MFBYTESTREAM_IS_WRITABLE = $00000002; + MFBYTESTREAM_IS_SEEKABLE = $00000004; + MFBYTESTREAM_IS_REMOTE = $00000008; + MFBYTESTREAM_IS_DIRECTORY = $00000080; + MFBYTESTREAM_HAS_SLOW_SEEK = $00000100; + MFBYTESTREAM_IS_PARTIALLY_DOWNLOADED = $00000200; + MFBYTESTREAM_SHARE_WRITE = $00000400; + MFBYTESTREAM_DOES_NOT_USE_NETWORK = $00000800; + MFBYTESTREAM_SEEK_FLAG_CANCEL_PENDING_IO = $00000001; + + msoBegin = 0; + msoCurrent = 1; + + STREAM_SEEK_SET = 0; + STREAM_SEEK_CUR = 1; + STREAM_SEEK_END = 2; + + STATFLAG_DEFAULT = 0; + STATFLAG_NONAME = 1; + STATFLAG_NOOPEN = 2; + + STGTY_STORAGE = 1; + STGTY_STREAM = 2; + STGTY_LOCKBYTES = 3; + STGTY_PROPERTY = 4; + + LOCK_WRITE = 1; + LOCK_EXCLUSIVE = 2; + LOCK_ONLYONCE = 4; + + MFVideoInterlace_Unknown = 0; + MFVideoInterlace_Progressive = 2; + MFVideoInterlace_FieldInterleavedUpperFirst = 3; + MFVideoInterlace_FieldInterleavedLowerFirst = 4; + MFVideoInterlace_FieldSingleUpper = 5; + MFVideoInterlace_FieldSingleLower = 6; + MFVideoInterlace_MixedInterlaceOrProgressive = 7; + MFVideoInterlace_Last = (MFVideoInterlace_MixedInterlaceOrProgressive+1); + MFVideoInterlace_ForceDWORD = $7fffffff; + + MFT_ENUM_FLAG_SYNCMFT = $00000001; + MFT_ENUM_FLAG_ASYNCMFT = $00000002; + MFT_ENUM_FLAG_HARDWARE = $00000004; + MFT_ENUM_FLAG_FIELDOFUSE = $00000008; + MFT_ENUM_FLAG_LOCALMFT = $00000010; + MFT_ENUM_FLAG_TRANSCODE_ONLY = $00000020; + MFT_ENUM_FLAG_SORTANDFILTER = $00000040; + MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY = $000000C0; + MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY = $00000140; + MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY_EDGEMODE= $00000240; + MFT_ENUM_FLAG_UNTRUSTED_STOREMFT = $00000400; + MFT_ENUM_FLAG_ALL = $0000003F; + + MFT_MESSAGE_COMMAND_FLUSH = $0; + MFT_MESSAGE_COMMAND_DRAIN = $1; + MFT_MESSAGE_SET_D3D_MANAGER = $2; + MFT_MESSAGE_DROP_SAMPLES = $3; + MFT_MESSAGE_COMMAND_TICK = $4; + MFT_MESSAGE_NOTIFY_BEGIN_STREAMING = $10000000; + MFT_MESSAGE_NOTIFY_END_STREAMING = $10000001; + MFT_MESSAGE_NOTIFY_END_OF_STREAM = $10000002; + MFT_MESSAGE_NOTIFY_START_OF_STREAM = $10000003; + MFT_MESSAGE_NOTIFY_RELEASE_RESOURCES = $10000004; + MFT_MESSAGE_NOTIFY_REACQUIRE_RESOURCES = $10000005; + MFT_MESSAGE_NOTIFY_EVENT = $10000006; + MFT_MESSAGE_COMMAND_SET_OUTPUT_STREAM_STATE = $10000007; + MFT_MESSAGE_COMMAND_FLUSH_OUTPUT_STREAM = $10000008; + MFT_MESSAGE_COMMAND_MARKER = $20000000; + + MEUnknown = 0; + MEError = 1; + MEExtendedType = 2; + MENonFatalError = 3; + MEGenericV1Anchor = MENonFatalError; + MESessionUnknown = 100; + MESessionTopologySet = 101; + MESessionTopologiesCleared = 102; + MESessionStarted = 103; + MESessionPaused = 104; + MESessionStopped = 105; + MESessionClosed = 106; + MESessionEnded = 107; + MESessionRateChanged = 108; + MESessionScrubSampleComplete = 109; + MESessionCapabilitiesChanged = 110; + MESessionTopologyStatus = 111; + MESessionNotifyPresentationTime = 112; + MENewPresentation = 113; + MELicenseAcquisitionStart = 114; + MELicenseAcquisitionCompleted = 115; + MEIndividualizationStart = 116; + MEIndividualizationCompleted = 117; + MEEnablerProgress = 118; + MEEnablerCompleted = 119; + MEPolicyError = 120; + MEPolicyReport = 121; + MEBufferingStarted = 122; + MEBufferingStopped = 123; + MEConnectStart = 124; + MEConnectEnd = 125; + MEReconnectStart = 126; + MEReconnectEnd = 127; + MERendererEvent = 128; + MESessionStreamSinkFormatChanged = 129; + MESessionV1Anchor = MESessionStreamSinkFormatChanged; + MESourceUnknown = 200; + MESourceStarted = 201; + MEStreamStarted = 202; + MESourceSeeked = 203; + MEStreamSeeked = 204; + MENewStream = 205; + MEUpdatedStream = 206; + MESourceStopped = 207; + MEStreamStopped = 208; + MESourcePaused = 209; + MEStreamPaused = 210; + MEEndOfPresentation = 211; + MEEndOfStream = 212; + MEMediaSample = 213; + MEStreamTick = 214; + MEStreamThinMode = 215; + MEStreamFormatChanged = 216; + MESourceRateChanged = 217; + MEEndOfPresentationSegment = 218; + MESourceCharacteristicsChanged = 219; + MESourceRateChangeRequested = 220; + MESourceMetadataChanged = 221; + MESequencerSourceTopologyUpdated = 222; + MESourceV1Anchor = MESequencerSourceTopologyUpdated; + MESinkUnknown = 300; + MEStreamSinkStarted = 301; + MEStreamSinkStopped = 302; + MEStreamSinkPaused = 303; + MEStreamSinkRateChanged = 304; + MEStreamSinkRequestSample = 305; + MEStreamSinkMarker = 306; + MEStreamSinkPrerolled = 307; + MEStreamSinkScrubSampleComplete = 308; + MEStreamSinkFormatChanged = 309; + MEStreamSinkDeviceChanged = 310; + MEQualityNotify = 311; + MESinkInvalidated = 312; + MEAudioSessionNameChanged = 313; + MEAudioSessionVolumeChanged = 314; + MEAudioSessionDeviceRemoved = 315; + MEAudioSessionServerShutdown = 316; + MEAudioSessionGroupingParamChanged = 317; + MEAudioSessionIconChanged = 318; + MEAudioSessionFormatChanged = 319; + MEAudioSessionDisconnected = 320; + MEAudioSessionExclusiveModeOverride = 321; + MESinkV1Anchor = MEAudioSessionExclusiveModeOverride; + MECaptureAudioSessionVolumeChanged = 322; + MECaptureAudioSessionDeviceRemoved = 323; + MECaptureAudioSessionFormatChanged = 324; + MECaptureAudioSessionDisconnected = 325; + MECaptureAudioSessionExclusiveModeOverride = 326; + MECaptureAudioSessionServerShutdown = 327; + MESinkV2Anchor = MECaptureAudioSessionServerShutdown; + METrustUnknown = 400; + MEPolicyChanged = 401; + MEContentProtectionMessage = 402; + MEPolicySet = 403; + METrustV1Anchor = MEPolicySet; + MEWMDRMLicenseBackupCompleted = 500; + MEWMDRMLicenseBackupProgress = 501; + MEWMDRMLicenseRestoreCompleted = 502; + MEWMDRMLicenseRestoreProgress = 503; + MEWMDRMLicenseAcquisitionCompleted = 506; + MEWMDRMIndividualizationCompleted = 508; + MEWMDRMIndividualizationProgress = 513; + MEWMDRMProximityCompleted = 514; + MEWMDRMLicenseStoreCleaned = 515; + MEWMDRMRevocationDownloadCompleted = 516; + MEWMDRMV1Anchor = MEWMDRMRevocationDownloadCompleted; + METransformUnknown = 600; + METransformNeedInput = METransformUnknown; + METransformHaveOutput = METransformNeedInput; + METransformDrainComplete = METransformHaveOutput; + METransformMarker = METransformDrainComplete; + METransformInputStreamStateChanged = METransformMarker+1; + MEByteStreamCharacteristicsChanged = 700; + MEVideoCaptureDeviceRemoved = 800; + MEVideoCaptureDevicePreempted = 801; + MEStreamSinkFormatInvalidatd = 802; + MEEncodingParameters = 803; + MEContentProtectionMetadata = 900; + MEDeviceThermalStateChanged = 950; + MEReservedMax = 10000; + + GUID_NULL: TGUID='{00000000-0000-0000-0000-000000000000}'; + MF_MT_MAJOR_TYPE: TGUID='{48eba18e-f8c9-4687-bf11-0a74c9f96a8f}'; + MFMediaType_Image: TGUID='{72178C23-E45B-11D5-BC2A-00B0D0F3F4AB}'; + MFMediaType_Video: TGUID='{73646976-0000-0010-8000-00AA00389B71}'; + MF_MT_SUBTYPE: TGUID='{f7e34c9a-42e8-4714-b74b-cb29d72c35e5}'; + MFImageFormat_JPEG: TGUID='{19e4a5aa-5662-4fc5-a0c0-1758028e1057}'; + MFImageFormat_RGB32: TGUID='{00000016-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_RGB24: TGUID='{00000014-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_RGB32: TGUID='{00000016-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_H264: TGUID='{34363248-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_WMV3: TGUID='{33564D57-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_MJPG: TGUID='{47504A4D-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_AYUV: TGUID='{56555941-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_NV12: TGUID='{3231564E-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_YUY2: TGUID='{32595559-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_IMC1: TGUID='{31434D49-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_IMC2: TGUID='{32434D49-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_IMC3: TGUID='{33434D49-0000-0010-8000-00aa00389b71}'; + MFVideoFormat_IMC4: TGUID='{34434D49-0000-0010-8000-00aa00389b71}'; + MF_TRANSCODE_CONTAINERTYPE: TGUID='{150ff23f-4abc-478b-ac4f-e1916fba1cca}'; + MFTranscodeContainerType_MPEG4: TGUID='{dc6cd05d-b9d0-40ef-bd35-fa622c1ab28a}'; + MFTranscodeContainerType_ASF: TGUID='{430f6f6e-b6bf-4fc1-a0bd-9ee46eee2afb}'; + MF_MT_INTERLACE_MODE: TGUID='{e2724bb8-e676-4806-b4b2-a8d6efb44ccd}'; + MF_TRANSCODE_ADJUST_PROFILE: TGUID='{9c37c21b-060f-487c-a690-80d7f50d1c72}'; + MF_MT_MPEG2_PROFILE: TGUID='{ad76a80b-2d5c-4e0b-b375-64e520137036}'; + MF_MT_FRAME_SIZE: TGUID='{1652c33d-d6b2-4012-b834-72030849a37d}'; + MF_MT_FRAME_RATE: TGUID='{c459a2e8-3d2c-4e44-b132-fee5156c7bb0}'; + MF_MT_PIXEL_ASPECT_RATIO: TGUID='{c6376a1e-8d0a-4027-be45-6d9a0ad39bb6}'; + MF_MT_AVG_BITRATE: TGUID='{20332624-fb0d-4d9e-bd0d-cbf6786c102e}'; + MF_BYTESTREAM_ORIGIN_NAME: TGUID='{fc358288-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_CONTENT_TYPE: TGUID='{fc358289-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_DURATION: TGUID='{fc35828a-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_LAST_MODIFIED_TIME: TGUID='{fc35828b-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_IFO_FILE_URI: TGUID='{fc35828c-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_DLNA_PROFILE_ID: TGUID='{fc35828d-3cb6-460c-a424-b6681260375a}'; + MF_BYTESTREAM_EFFECTIVE_URL: TGUID='{9afa0209-89d1-42af-8456-1de6b562d691}'; + MF_BYTESTREAM_TRANSCODED: TGUID='{b6c5c282-4dc9-4db9-ab48-cf3b6d8bc5e0}'; + MFT_CATEGORY_VIDEO_DECODER: TGUID='{d6c02d4b-6833-45b4-971a-05a4b04bab91}'; + MFT_CATEGORY_VIDEO_ENCODER: TGUID='{f79eac7d-e545-4387-bdee-d647d7bde42a}'; + + eAVEncH264VProfile_unknown = 0; + eAVEncH264VProfile_Simple = 66; + eAVEncH264VProfile_Base = 66; + eAVEncH264VProfile_Main = 77; + eAVEncH264VProfile_High = 100; + eAVEncH264VProfile_422 = 122; + eAVEncH264VProfile_High10 = 110; + eAVEncH264VProfile_444 = 244; + eAVEncH264VProfile_Extended = 88; + eAVEncH264VProfile_ScalableBase = 83; + eAVEncH264VProfile_ScalableHigh = 86; + eAVEncH264VProfile_MultiviewHigh = 118; + eAVEncH264VProfile_StereoHigh = 128; + eAVEncH264VProfile_ConstrainedBase = 256; + eAVEncH264VProfile_UCConstrainedHigh = 257; + eAVEncH264VProfile_UCScalableConstrainedBase = 258; + eAVEncH264VProfile_UCScalableConstrainedHigh = 259; + + AVIF_HASINDEX =$00000010; + AVIF_MUSTUSEINDEX =$00000020; + AVIF_ISINTERLEAVED =$00000100; + AVIF_TRUSTCKTYPE =$00000800; + AVIF_WASCAPTUREFILE =$00010000; + AVIF_COPYRIGHTED =$00020000; + AVI_MAX_RIFF_SIZE =$40000000; + AVI_MAX_STREAM_COUNT =100; + AVIIF_INDEX =$00000010; + AVIIF_NO_TIME =$00000100; + AVISF_DISABLED =$00000001; + AVISF_VIDEO_PALCHANGES =$00010000; + + VT_EMPTY = 0; { [V] [P] nothing } + VT_NULL = 1; { [V] SQL style Null } + VT_I2 = 2; { [V][T][P] 2 byte signed int } + VT_I4 = 3; { [V][T][P] 4 byte signed int } + VT_R4 = 4; { [V][T][P] 4 byte real } + VT_R8 = 5; { [V][T][P] 8 byte real } + VT_CY = 6; { [V][T][P] currency } + VT_DATE = 7; { [V][T][P] date } + VT_BSTR = 8; { [V][T][P] binary string } + VT_DISPATCH = 9; { [V][T] IDispatch FAR* } + VT_ERROR = 10; { [V][T] SCODE } + VT_BOOL = 11; { [V][T][P] True=-1, False=0 } + VT_VARIANT = 12; { [V][T][P] VARIANT FAR* } + VT_UNKNOWN = 13; { [V][T] IUnknown FAR* } + VT_DECIMAL = 14; { [V][T] [S] 16 byte fixed point } + VT_I1 = 16; { [T] signed char } + VT_UI1 = 17; { [T] unsigned char } + VT_UI2 = 18; { [T] unsigned short } + VT_UI4 = 19; { [T] unsigned long } + VT_I8 = 20; { [T][P] signed 64-bit int } + VT_UI8 = 21; { [T] unsigned 64-bit int } + VT_INT = 22; { [T] signed machine int } + VT_UINT = 23; { [T] unsigned machine int } + VT_VOID = 24; { [T] C style void } + VT_HRESULT = 25; { [T] } + VT_PTR = 26; { [T] pointer type } + VT_SAFEARRAY = 27; { [T] (use VT_ARRAY in VARIANT) } + VT_CARRAY = 28; { [T] C style array } + VT_USERDEFINED = 29; { [T] user defined type } + VT_LPSTR = 30; { [T][P] null terminated string } + VT_LPWSTR = 31; { [T][P] wide null terminated string } + VT_FILETIME = 64; { [P] FILETIME } + VT_BLOB = 65; { [P] Length prefixed bytes } + VT_STREAM = 66; { [P] Name of the stream follows } + VT_STORAGE = 67; { [P] Name of the storage follows } + VT_STREAMED_OBJECT = 68; { [P] Stream contains an object } + VT_STORED_OBJECT = 69; { [P] Storage contains an object } + VT_BLOB_OBJECT = 70; { [P] Blob contains an object } + VT_CF = 71; { [P] Clipboard format } + VT_CLSID = 72; { [P] A Class ID } + VT_VECTOR = $1000; { [P] simple counted array } + VT_ARRAY = $2000; { [V] SAFEARRAY* } + VT_BYREF = $4000; { [V] } + VT_RESERVED = $8000; + VT_ILLEGAL = $ffff; + VT_ILLEGALMASKED = $0fff; + VT_TYPEMASK = $0fff; + +type + PDecimal = ^tagDEC; + tagDEC = packed record + wReserved: Word; + case Integer of + 0: (scale, sign: Byte; Hi32: Longint; + case Integer of + 0: (Lo32, Mid32: Longint); + 1: (Lo64: LONGLONG)); + 1: (signscale: Word); + end; + + tagSAFEARRAYBOUND = record + cElements: Longint; + lLbound: Longint; + end; + + PSafeArray = ^tagSAFEARRAY; + tagSAFEARRAY =record + cDims: Word; + fFeatures: Word; + cbElements: Longint; + cLocks: Longint; + pvData: Pointer; + rgsabound: array[0..0] of tagSAFEARRAYBOUND; + end; + + tagVARIANT =record + vt: TVarType; + wReserved1: Word; + wReserved2: Word; + wReserved3: Word; + case Integer of + VT_UI1: (bVal: Byte); + VT_I2: (iVal: Smallint); + VT_I4: (lVal: Longint); + VT_R4: (fltVal: Single); + VT_R8: (dblVal: Double); + VT_BOOL: (vbool: WordBool); + VT_ERROR: (scode: LongInt); + VT_CY: (cyVal: Currency); + VT_DATE: (date: Double); + VT_BSTR: (bstrVal: PWideChar{WideString}); + VT_UNKNOWN: (unkVal: Pointer{IUnknown}); + VT_DISPATCH: (dispVal: Pointer{IDispatch}); + VT_ARRAY: (parray: PSafeArray); + VT_BYREF or VT_UI1: (pbVal: ^Byte); + VT_BYREF or VT_I2: (piVal: ^Smallint); + VT_BYREF or VT_I4: (plVal: ^Longint); + VT_BYREF or VT_R4: (pfltVal: ^Single); + VT_BYREF or VT_R8: (pdblVal: ^Double); + VT_BYREF or VT_BOOL: (pbool: ^WordBool); + VT_BYREF or VT_ERROR: (pscode: ^LongInt); + VT_BYREF or VT_CY: (pcyVal: ^Currency); + VT_BYREF or VT_DATE: (pdate: ^Double); + VT_BYREF or VT_BSTR: (pbstrVal: ^WideString); + VT_BYREF or VT_UNKNOWN: (punkVal: ^IUnknown); + VT_BYREF or VT_DISPATCH: (pdispVal: ^IDispatch); + VT_BYREF or VT_ARRAY: (pparray: ^PSafeArray); + VT_BYREF or VT_VARIANT: (pvarVal: PVariant); + VT_BYREF: (byRef: Pointer); + VT_I1: (cVal: AnsiChar); + VT_UI2: (uiVal: Word); + VT_UI4: (ulVal: LongWord); + VT_INT: (intVal: Integer); + VT_UINT: (uintVal: LongWord); + VT_BYREF or VT_DECIMAL: (pdecVal: PDecimal); + VT_BYREF or VT_I1: (pcVal: PAnsiChar); + VT_BYREF or VT_UI2: (puiVal: PWord); + VT_BYREF or VT_UI4: (pulVal: PInteger); + VT_BYREF or VT_INT: (pintVal: PInteger); + VT_BYREF or VT_UINT: (puintVal: PLongWord); + end; + + tagSTATSTG =record + pwcsName: PWideChar; + dwType: Longint; + cbSize: int64; + mtime: TFileTime; + ctime: TFileTime; + atime: TFileTime; + grfMode: Longint; + grfLocksSupported: Longint; + clsid: TGUID; + grfStateBits: Longint; + reserved: Longint; + end; + + RECT16 =packed record + x1: word; + y1: word; + x2: word; + y2: word; + end; + + AVIMAINHEADER =packed record + dwMicroSecPerFrame: Cardinal; // frame display rate (or 0) + dwMaxBytesPerSec: Cardinal; // max. transfer rate + dwPaddingGranularity: Cardinal; // pad to multiples of this size; + dwFlags: Cardinal; // the ever-present flags + dwTotalFrames: Cardinal; // # frames in file + dwInitialFrames: Cardinal; + dwStreams: Cardinal; + dwSuggestedBufferSize: Cardinal; + dwWidth: Cardinal; + dwHeight: Cardinal; + dwReserved: array[0..3] of Cardinal; + end; + + AVIStreamHeader=packed record + fccType: array[0..3] of AnsiChar; + fccHandler: array[0..3] of AnsiChar; + dwFlags: Cardinal; + wPriority: word; + wLanguage: word; + dwInitialFrames: Cardinal; + dwScale: Cardinal; + dwRate: Cardinal; + dwStart: Cardinal; + dwLength: Cardinal; + dwSuggestedBufferSize: Cardinal; + dwQuality: Cardinal; + dwSampleSize: Cardinal; + rcFrame: RECT16; + end; + + PROPERTYKEY =packed record + fmtid: TGUID; + pid: Cardinal; + end; + PPROPERTYKEY=^PROPERTYKEY; + + MFint64 =packed record + case byte of + 0:(lo,hi: Cardinal); + 1:(int_64: int64); + end; + + AACProfileInfo=packed record + samplesPerSec: Cardinal; + numChannels: Cardinal; + bitsPerSample: Cardinal; + bytesPerSec: Cardinal; + aacProfile: Cardinal; + end; + + MFRatio =packed record + Numerator: Cardinal; + Denominator: Cardinal; + end; + + H264ProfileInfo=packed record + profile: Cardinal; + fps: MFint64; + frame_size: MFint64; + bitrate: Cardinal; + end; + + MFT_REGISTER_TYPE_INFO=packed record + guidMajorType: TGUID; + guidSubtype: TGUID; + end; + PMFT_REGISTER_TYPE_INFO=^MFT_REGISTER_TYPE_INFO; + + MFT_OUTPUT_STREAM_INFO=packed record + dwFlags: Cardinal; + cbSize: Cardinal; + cbAlignment: Cardinal; + end; + PMFT_OUTPUT_STREAM_INFO=^MFT_OUTPUT_STREAM_INFO; + + MF_SINK_WRITER_STATISTICS =packed record + cb: Cardinal; + llLastTimestampReceived: int64; + llLastTimestampEncoded: int64; + llLastTimestampProcessed: int64; + llLastStreamTickReceived: int64; + llLastSinkSampleRequest: int64; + qwNumSamplesReceived: int64; + qwNumSamplesEncoded: int64; + qwNumSamplesProcessed: int64; + qwNumStreamTicksReceived: int64; + dwByteCountQueued: int64; + qwByteCountProcessed: int64; + dwNumOutstandingSinkSampleRequests: Cardinal; + dwAverageSampleRateReceived: Cardinal; + dwAverageSampleRateEncoded: Cardinal; + dwAverageSampleRateProcessed: Cardinal; + end; + PMF_SINK_WRITER_STATISTICS=^MF_SINK_WRITER_STATISTICS; + + MFCLOCK_PROPERTIES=packed record + qwCorrelationRate: int64; + guidClockId: PGUID; + dwClockFlags: Cardinal; + qwClockFrequency: int64; + dwClockTolerance: Cardinal; + dwClockJitter: Cardinal; + end; + PMFCLOCK_PROPERTIES=^MFCLOCK_PROPERTIES; + + IMFAttributes=interface(IUnknown) + ['{2cd2d921-c447-44a7-a13c-4adabfc247e3}'] + function GetItem(const guidKey: TGUID;pValue: PVARIANT): LongInt;stdcall; + function GetItemType(const guidKey: TGUID;pType: PCardinal): LongInt;stdcall; + function CompareItem(const guidKey: TGUID;Value: PVARIANT;pbResult: pboolean): LongInt;stdcall; + function Compare(const pTheirs: IMFAttributes;MatchType: Cardinal;pbResult: pboolean): LongInt;stdcall; + function GetUINT32(const guidKey: TGUID;punValue: PCardinal): LongInt;stdcall; + function GetUINT64(const guidKey: TGUID;punValue: pint64): LongInt;stdcall; + function GetDouble(const guidKey: TGUID;pfValue: pdouble): LongInt;stdcall; + function GetGUID(const guidKey,PGUIDValue: TGUID): LongInt;stdcall; + function GetStringLength(const guidKey: TGUID;pcchLength: PCardinal): LongInt;stdcall; + function GetString(const guidKey: TGUID;pwszValue: PWideChar;cchBufSize: Cardinal;pcchLength: PCardinal): LongInt;stdcall; + function GetAllocatedString(const guidKey: TGUID;ppwszValue: ppointer;pcchLength: PCardinal): LongInt;stdcall; + function GetBlobSize(const guidKey: TGUID;pcbBlobSize: PCardinal): LongInt;stdcall; + function GetBlob(const guidKey: TGUID;pBuf: pointer;cbBufSize: Cardinal;pcbBlobSize: PCardinal): LongInt;stdcall; + function GetAllocatedBlob(const guidKey: TGUID;ppBuf: ppointer;pcbSize: pCardinal): LongInt;stdcall; + function GetUnknown(const guidKey,riid: TGUID;ppv: ppointer): LongInt;stdcall; + function SetItem(const guidKey: TGUID;Value: PVARIANT): LongInt;stdcall; + function DeleteItem(const guidKey: TGUID): LongInt;stdcall; + function DeleteAllItems: LongInt;stdcall; + function SetUINT32(const guidKey: TGUID;unValue: Cardinal): LongInt;stdcall; + function SetUINT64(const guidKey: TGUID;const unValue: int64): LongInt;stdcall; + function SetDouble(const guidKey: TGUID;fValue: double): LongInt;stdcall; + function SetGUID(const guidKey,guidValue: TGUID): LongInt;stdcall; + function SetString(const guidKey: TGUID;wszValue: PWideChar): LongInt;stdcall; + function SetBlob(const guidKey: TGUID;pBuf: pointer;cbBufSize: Cardinal): LongInt;stdcall; + function SetUnknown(const guidKey: TGUID;const pUnknown: IUnknown): LongInt;stdcall; + function LockStore: LongInt;stdcall; + function UnlockStore: LongInt;stdcall; + function GetCount(pcItems: PCardinal): LongInt;stdcall; + function GetItemByIndex(unIndex: Cardinal;const PGUIDKey: TGUID;pValue: PVARIANT): LongInt;stdcall; + function CopyAllItems(const pDest: IMFAttributes): LongInt;stdcall; + end; + PMFAttributes=^IMFAttributes; + + IMFMediaEvent=interface(IMFAttributes) + ['{DF598932-F10C-4E39-BBA2-C308F101DAA3}'] + function GetType(pmet: PCardinal): LongInt;stdcall; + function GetExtendedType(PGUIDExtendedType: PGUID): LongInt;stdcall; + function GetStatus(phrStatus: PCardinal): LongInt;stdcall; + function GetValue(pvValue: PVARIANT): LongInt;stdcall; + end; + PMFMediaEvent=^IMFMediaEvent; + + IMFAsyncResult=interface(IUnknown) + ['{ac6b7889-0740-4d51-8619-905994a55cc6}'] + function GetState(ppunkState: PUnknown): LongInt;stdcall; + function GetStatus: LongInt;stdcall; + function SetStatus(hrStatus: Cardinal): LongInt;stdcall; + function GetObject(ppObject: PUnknown): LongInt;stdcall; + function GetStateNoAddRef: LongInt;stdcall; + end; + PMFAsyncResult=^IMFAsyncResult; + + IMFAsyncCallback=interface(IUnknown) + ['{a27003cf-2354-4f2a-8d6a-ab7cff15437e}'] + function GetParameters(pdwFlags,pdwQueue: PCardinal): LongInt;stdcall; + function Invoke(pAsyncResult: IMFAsyncResult): LongInt;stdcall; + end; + PMFAsyncCallback=^IMFAsyncCallback; + + IMFMediaEventGenerator=interface(IUnknown) + ['{2CD0BD52-BCD5-4B89-B62C-EADC0C031E7D}'] + function GetEvent(dwFlags: cardinal;ppEvent: PMFMediaEvent): LongInt;stdcall; + function BeginGetEvent(pCallback: IMFAsyncCallback;punkState: IUnknown): LongInt;stdcall; + function EndGetEvent(pResult: IMFAsyncResult;ppEvent: PMFMediaEvent): LongInt;stdcall; + function QueueEvent(met: Cardinal;guidExtendedType: PGUID;hrStatus: Cardinal;pvValue: PVARIANT): LongInt;stdcall; + end; + PMFMediaEventGenerator=^IMFMediaEventGenerator; + + IMFMediaType=interface(IMFAttributes) + ['{44ae0fa8-ea31-4109-8d2e-4cae4997c555}'] + function GetMajorType(PGUIDMajorType: PGUID): LongInt;stdcall; + function IsCompressedFormat(pfCompressed: pboolean): LongInt;stdcall; + function IsEqual(pIMediaType: IMFMediaType;pdwFlags: PCardinal): LongInt;stdcall; + function GetRepresentation(guidRepresentation: PGUID;ppvRepresentation: pointer): LongInt;stdcall; + function FreeRepresentation(guidRepresentation: PGUID;pvRepresentation: pointer): LongInt;stdcall; + end; + PMFMediaType=^IMFMediaType; + + IMFMediaTypeHandler=interface(IUnknown) + ['{e93dcf6c-4b07-4e1e-8123-aa16ed6eadf5}'] + function IsMediaTypeSupported(pMediaType,ppMediaType: PMFMediaType): LongInt;stdcall; + function GetMediaTypeCount(pdwTypeCount: PCardinal): LongInt;stdcall; + function GetMediaTypeByIndex(dwIndex: Cardinal;ppType: pMFMediaType): LongInt;stdcall; + function SetCurrentMediaType(pMediaType: IMFMediaType): LongInt;stdcall; + function GetCurrentMediaType(ppMediaType: PMFMediaType): LongInt;stdcall; + function GetMajorType(PGUIDMajorType: PGUID): LongInt;stdcall; + end; + PMFMediaTypeHandler=^IMFMediaTypeHandler; + + IMFStreamDescriptor=interface(IMFAttributes) + ['{56c03d9c-9dbb-45f5-ab4b-d80f47c05938}'] + function GetStreamIdentifier(pdwStreamIdentifier: PCardinal): LongInt;stdcall; + function GetMediaTypeHandler(ppMediaTypeHandler: PMFMediaTypeHandler): LongInt;stdcall; + end; + PMFStreamDescriptor=^IMFStreamDescriptor; + + IMFPresentationDescriptor=interface(IMFAttributes) + ['{03cb2711-24d7-4db6-a17f-f3a7a479a536}'] + function GetStreamDescriptorCount(pdwDescriptorCount: PCardinal): LongInt;stdcall; + function GetStreamDescriptorByIndex(dwIndex: Cardinal;pfSelected: pboolean;ppDescriptor: PMFStreamDescriptor): LongInt;stdcall; + function SelectStream(dwDescriptorIndex: Cardinal): LongInt;stdcall; + function DeselectStream(dwDescriptorIndex: Cardinal): LongInt;stdcall; + function Clone(out ppPresentationDescriptor: IMFPresentationDescriptor): LongInt;stdcall; + end; + PMFPresentationDescriptor=^IMFPresentationDescriptor; + + IMFMediaSource=interface(IMFMediaEventGenerator) + ['{279a808d-aec7-40c8-9c6b-a6b492c78a66}'] + function GetCharacteristics(pdwCharacteristics: pcardinal): LongInt;stdcall; + function CreatePresentationDescriptor(ppPresentationDescriptor: PMFPresentationDescriptor): LongInt;stdcall; + function Start(pPresentationDescriptor: IMFPresentationDescriptor;PGUIDTimeFormat: PGUID;pvarStartPosition: PVARIANT): LongInt;stdcall; + function Stop: LongInt;stdcall; + function Pause: LongInt;stdcall; + function Shutdown: LongInt;stdcall; + end; + PMFMediaSource=^IMFMediaSource; + + IMFTranscodeProfile=interface(IUnknown) + ['{4ADFDBA3-7AB0-4953-A62B-461E7FF3DA1E}'] + function SetAudioAttributes(pAttrs: IMFAttributes): LongInt;stdcall; + function GetAudioAttributes(ppAttrs: PMFAttributes): LongInt;stdcall; + function SetVideoAttributes(pAttrs: IMFAttributes): LongInt;stdcall; + function GetVideoAttributes(ppAttrs: PMFAttributes): LongInt;stdcall; + function SetContainerAttributes(pAttrs: IMFAttributes): LongInt;stdcall; + function GetContainerAttributes(ppAttrs: PMFAttributes): LongInt;stdcall; + end; + PMFTranscodeProfile=^IMFTranscodeProfile; + + IMFTopologyNode=interface(IMFAttributes) + ['{83CF873A-F6DA-4bc8-823F-BACFD55DC430}'] + function SetObject(pObject: IUnknown): LongInt;stdcall; + function GetObject(ppObject: PUnknown): LongInt;stdcall; + function GetNodeType(pType: PCardinal): LongInt;stdcall; + function GetTopoNodeID(pID: pint64): LongInt;stdcall; + function SetTopoNodeID(const ullTopoID: int64): LongInt;stdcall; + function GetInputCount(pcInputs: PCardinal): LongInt;stdcall; + function GetOutputCount(pcOutputs: PCardinal): LongInt;stdcall; + function ConnectOutput(dwOutputIndex: Cardinal;pDownstreamNode: IMFTopologyNode;dwInputIndexOnDownstreamNode: Cardinal): LongInt;stdcall; + function DisconnectOutput(dwOutputIndex: Cardinal): LongInt;stdcall; + function GetInput(dwInputIndex: Cardinal;out ppUpstreamNode: IMFTopologyNode;pdwOutputIndexOnUpstreamNode: PCardinal): LongInt;stdcall; + function GetOutput(dwOutputIndex: Cardinal;out ppDownstreamNode: IMFTopologyNode;pdwInputIndexOnDownstreamNode: PCardinal): LongInt;stdcall; + function SetOutputPrefType(dwOutputIndex: PCardinal;pType: IMFMediaType): LongInt;stdcall; + function GetOutputPrefType(dwOutputIndex: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function SetInputPrefType(dwInputIndex: Cardinal;pType: IMFMediaType): LongInt;stdcall; + function GetInputPrefType(dwInputIndex: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function CloneFrom(pNode: IMFTopologyNode): LongInt;stdcall; + end; + PMFTopologyNode=^IMFTopologyNode; + + IMFCollection=interface(IUnknown) + ['{5BC8A76B-869A-46a3-9B03-FA218A66AEBE}'] + function GetElementCount(pcElements: PCardinal): LongInt;stdcall; + function GetElement(dwElementIndex: Cardinal;ppUnkElement: PUnknown): LongInt;stdcall; + function AddElement(pUnkElement: IUnknown): LongInt;stdcall; + function RemoveElement(dwElementIndex: Cardinal;ppUnkElement: PUnknown): LongInt;stdcall; + function InsertElementAt(dwIndex: Cardinal;pUnknown: IUnknown): LongInt;stdcall; + function RemoveAllElements: LongInt;stdcall; + end; + PMFCollection=^IMFCollection; + + IMFTopology=interface(IMFAttributes) + ['{83CF873A-F6DA-4bc8-823F-BACFD55DC433}'] + function GetTopologyID(pID: pint64): LongInt;stdcall; + function AddNode(pNode: IMFTopologyNode): LongInt;stdcall; + function RemoveNode(pNode: IMFTopologyNode): LongInt;stdcall; + function GetNodeCount(pwNodes: pword): LongInt;stdcall; + function GetNode(wIndex: word;ppNode: PMFTopologyNode): LongInt;stdcall; + function Clear: LongInt;stdcall; + function CloneFrom(pTopology: IMFTopology): LongInt;stdcall; + function GetNodeByID(const qwTopoNodeID: int64;ppNode: PMFTopologyNode): LongInt;stdcall; + function GetSourceNodeCollection(ppCollection: PMFCollection): LongInt;stdcall; + function GetOutputNodeCollection(ppCollection: PMFCollection): LongInt;stdcall; + end; + PMFTopology=^IMFTopology; + + IMFClock=interface(IUnknown) + ['{2eb1e945-18b8-4139-9b1a-d5d584818530}'] + function GetClockCharacteristics(pdwCharacteristics: PCardinal): LongInt;stdcall; + function GetCorrelatedTime(dwReserved: Cardinal;pllClockTime: pint64;const phnsSystemTime: int64): LongInt;stdcall; + function GetContinuityKey(pdwContinuityKey: PCardinal): LongInt;stdcall; + function GetState(dwReserved: Cardinal;peClockState: PCardinal): LongInt;stdcall; + function GetProperties(pClockProperties: PMFCLOCK_PROPERTIES): LongInt;stdcall; + end; + PMFClock=^IMFClock; + + IMFPresentationTimeSource=interface(IMFClock) + ['{7FF12CCE-F76F-41c2-863B-1666C8E5E139}'] + function GetUnderlyingClock(ppClock: PMFClock): LongInt;stdcall; + end; + PMFPresentationTimeSource=^IMFPresentationTimeSource; + + IMFClockStateSink=interface(IUnknown) + ['{F6696E82-74F7-4f3d-A178-8A5E09C3659F}'] + function OnClockStart(const hnsSystemTime,llClockStartOffset: int64): LongInt;stdcall; + function OnClockStop(const hnsSystemTime: int64): LongInt;stdcall; + function OnClockPause(const hnsSystemTime: int64): LongInt;stdcall; + function OnClockRestart(const hnsSystemTime: int64): LongInt;stdcall; + function OnClockSetRate(const hnsSystemTime: int64;flRate: single): LongInt;stdcall; + end; + + IMFPresentationClock=interface(IMFClock) + ['{868CE85C-8EA9-4f55-AB82-B009A910A805}'] + function SetTimeSource(pTimeSource: IMFPresentationTimeSource): LongInt;stdcall; + function GetTimeSource(ppTimeSource: PMFPresentationTimeSource): LongInt;stdcall; + function GetTime(phnsClockTime: pint64): LongInt;stdcall; + function AddClockStateSink(pStateSink: IMFClockStateSink): LongInt;stdcall; + function RemoveClockStateSink(pStateSink: IMFClockStateSink): LongInt;stdcall; + function Start(const llClockStartOffset: int64): LongInt;stdcall; + function Stop: LongInt;stdcall; + function Pause: LongInt;stdcall; + end; + PMFPresentationClock=^IMFPresentationClock; + + IMFMediaSession=interface(IMFMediaEventGenerator) + ['{90377834-21D0-4dee-8214-BA2E3E6C1127}'] + function SetTopology(dwSetTopologyFlags: Cardinal;const pTopology: IMFTopology): LongInt;stdcall; + function ClearTopologies: LongInt;stdcall; + function Start(pguidTimeFormat: PGUID;pvarStartPosition: PVARIANT): LongInt;stdcall; + function Pause: LongInt;stdcall; + function Stop: LongInt;stdcall; + function Close: LongInt;stdcall; + function Shutdown: LongInt;stdcall; + function GetClock(ppClock: PMFClock): LongInt;stdcall; + function GetSessionCapabilities(pdwCaps: PCardinal): LongInt;stdcall; + function GetFullTopology(dwGetFullTopologyFlags: Cardinal;const TopoId: int64;ppFullTopology: PMFTopology): LongInt;stdcall; + end; + PMFMediaSession=^IMFMediaSession; + + IMFByteStream=interface(IUnknown) + ['{ad4c1b00-4bf7-422f-9175-756693d9130d}'] + function GetCapabilities(pdwCapabilities: PCardinal): LongInt;stdcall; + function GetLength(pqwLength: pint64): LongInt;stdcall; + function SetLength(const qwLength: int64): LongInt;stdcall; + function GetCurrentPosition(pqwPosition: pint64): LongInt;stdcall; + function SetCurrentPosition(const qwPosition: int64): LongInt;stdcall; + function IsEndOfStream(pfEndOfStream: pboolean): LongInt;stdcall; + function Read(pb: pointer;cb: Cardinal;pcbRead: PCardinal): LongInt;stdcall; + function BeginRead(pb: pointer;cb: Cardinal;const pCallback: IMFAsyncCallback;const punkState: IUnknown): LongInt;stdcall; + function EndRead(const pResult: IMFAsyncResult;pcbRead: PCardinal): LongInt;stdcall; + function Write(pb: pointer;cb: Cardinal;pcbWritten: PCardinal): LongInt;stdcall; + function BeginWrite(pb: pointer;cb: Cardinal;const pCallback: IMFAsyncCallback;const punkState: IUnknown): LongInt;stdcall; + function EndWrite(const pResult: IMFAsyncResult;pcbWritten: PCardinal): LongInt;stdcall; + function Seek(SeekOrigin: Cardinal;const llSeekOffset: int64;dwSeekFlags: Cardinal;pqwCurrentPosition: pint64): LongInt;stdcall; + function Flush: LongInt;stdcall; + function Close: LongInt;stdcall; + end; + PMFByteStream=^IMFByteStream; + + IPropertyStore=interface(IUnknown) + ['{886d8eeb-8cf2-4446-8d02-cdba1dbdcf99}'] + function GetCount(cProps: PCardinal): LongInt;stdcall; + function GetAt(iProp: Cardinal;pkey: PPROPERTYKEY): LongInt;stdcall; + function GetValue(key: PPROPERTYKEY;pv: PVARIANT): LongInt;stdcall; + function SetValue(key: PPROPERTYKEY;propvar: PVARIANT): LongInt;stdcall; + function Commit: LongInt;stdcall; + end; + PPropertyStore=^IPropertyStore; + + ISequentialStream = interface(IUnknown) + ['{0c733a30-2a1c-11ce-ade5-00aa0044773d}'] + function Read(pv: Pointer; cb: Longint; pcbRead: PLongint): LongInt;stdcall; + function Write(pv: Pointer; cb: Longint; pcbWritten: PLongint): LongInt;stdcall; + end; + + IStream = interface(ISequentialStream) + ['{0000000C-0000-0000-C000-000000000046}'] + function Seek(dlibMove: int64; dwOrigin: Longint; libNewPosition: pint64): LongInt; stdcall; + function SetSize(libNewSize: int64): LongInt; stdcall; + function CopyTo(stm: IStream; cb: int64; out cbRead: int64; cbWritten: pint64): LongInt; stdcall; + function Commit(grfCommitFlags: Longint): LongInt; stdcall; + function Revert: LongInt; stdcall; + function LockRegion(libOffset: int64; cb: int64; dwLockType: Longint): LongInt; stdcall; + function UnlockRegion(libOffset: int64; cb: int64; dwLockType: Longint): LongInt; stdcall; + function Stat(out statstg: tagSTATSTG; grfStatFlag: Longint): LongInt;stdcall; + function Clone(out stm: IStream): LongInt; stdcall; + end; + + IMFSourceResolver=interface(IUnknown) + ['{FBE5A32D-A497-4b61-BB85-97B1A848A6E3}'] + function CreateObjectFromURL(pwszURL: PWideChar;dwFlags: Cardinal;pProps: PPropertyStore;pObjectType: PCardinal;ppObject: PUnknown): LongInt;stdcall; + function CreateObjectFromByteStream(const pByteStream: IMFByteStream;pwszURL: PWideChar;dwFlags: Cardinal;pProps: PPropertyStore;pObjectType: PCardinal;ppObject: PUnknown): LongInt;stdcall; + function BeginCreateObjectFromURL(pwszURL: PWideChar;dwFlags: Cardinal;const pProps: IPropertyStore;ppIUnknownCancelCookie: PUnknown;const pCallback: IMFAsyncCallback;const punkState: IUnknown): LongInt;stdcall; + function EndCreateObjectFromURL(const pResult: IMFAsyncResult;pObjectType: PCardinal;ppObject: PUnknown): LongInt;stdcall; + function BeginCreateObjectFromByteStream(const pByteStream: IMFByteStream;pwszURL: PWideChar;dwFlags: Cardinal;const pProps: IPropertyStore;ppIUnknownCancelCookie: PUnknown;const pCallback: IMFAsyncCallback;const punkState: IUnknown): LongInt;stdcall; + function EndCreateObjectFromByteStream(const pResult: IMFAsyncResult;pObjectType: PCardinal;ppObject: PUnknown): LongInt;stdcall; + function CancelObjectCreation(const pIUnknownCancelCookie: IUnknown): LongInt;stdcall; + end; + PMFSourceResolver=^IMFSourceResolver; + + IMFMediaBuffer=interface(IUnknown) + ['{045FA593-8799-42b8-BC8D-8968C6453507}'] + function Lock(ppbBuffer: ppointer;pcbMaxLength,pcbCurrentLength: PCardinal): LongInt;stdcall; + function Unlock: LongInt;stdcall; + function GetCurrentLength(pcbCurrentLength: PCardinal): LongInt;stdcall; + function SetCurrentLength(cbCurrentLength: Cardinal): LongInt;stdcall; + function GetMaxLength(pcbMaxLength: PCardinal): LongInt;stdcall; + end; + PMFMediaBuffer=^IMFMediaBuffer; + + IMFSample=interface(IMFAttributes) + ['{c40a00f2-b93a-4d80-ae8c-5a1c634f58e4}'] + function GetSampleFlags(pdwSampleFlags: PCardinal): LongInt;stdcall; + function SetSampleFlags(dwSampleFlags: Cardinal): LongInt;stdcall; + function GetSampleTime(phnsSampleTime: pint64): LongInt;stdcall; + function SetSampleTime(hnsSampleTime: int64): LongInt;stdcall; + function GetSampleDuration(phnsSampleDuration: pint64): LongInt;stdcall; + function SetSampleDuration(hnsSampleDuration: int64): LongInt;stdcall; + function GetBufferCount(pdwBufferCount: PCardinal): LongInt;stdcall; + function GetBufferByIndex(dwIndex: Cardinal;ppBuffer: PMFMediaBuffer): LongInt;stdcall; + function ConvertToContiguousBuffer(ppBuffer: PMFMediaBuffer): LongInt;stdcall; + function AddBuffer(const pBuffer: IMFMediaBuffer): LongInt;stdcall; + function RemoveBufferByIndex(dwIndex: Cardinal): LongInt;stdcall; + function RemoveAllBuffers: LongInt;stdcall; + function GetTotalLength(pcbTotalLength: PCardinal): LongInt;stdcall; + function CopyToBuffer(const pBuffer: IMFMediaBuffer): LongInt;stdcall; + end; + PMFSample=^IMFSample; + + IMFSinkWriter=interface(IUnknown) + ['{3137f1cd-fe5e-4805-a5d8-fb477448cb3d}'] + function AddStream(const pTargetMediaType: IMFMediaType;out pdwStreamIndex: Cardinal): LongInt;stdcall; + function SetInputMediaType(dwStreamIndex: Cardinal;const pInputMediaType: IMFMediaType;const pEncodingParameters: IMFAttributes): LongInt;stdcall; + function BeginWriting: LongInt;stdcall; + function WriteSample(dwStreamIndex: Cardinal;const pSample: IMFSample): LongInt;stdcall; + function SendStreamTick(dwStreamIndex: Cardinal;llTimestamp: int64): LongInt;stdcall; + function PlaceMarker(dwStreamIndex: Cardinal;pvContext: pointer): LongInt;stdcall; + function NotifyEndOfSegment(dwStreamIndex: Cardinal): LongInt;stdcall; + function Flush(dwStreamIndex: Cardinal): LongInt;stdcall; + function Finalize: LongInt;stdcall; + function GetServiceForStream(dwStreamIndex: Cardinal;guidService,riid: PGUID;ppvObject: pointer): LongInt;stdcall; + function GetStatistics(dwStreamIndex: Cardinal;pStats: PMF_SINK_WRITER_STATISTICS): LongInt;stdcall; + end; + PIMFSinkWriter=^IMFSinkWriter; + + IMFActivate=interface(IMFAttributes) + ['{7FEE9E9A-4A89-47a6-899C-B6A53A70FB67}'] + function ActivateObject(const riid: TGUID;ppv: ppointer): LongInt;stdcall; + function ShutdownObject: LongInt;stdcall; + function DetachObject: LongInt;stdcall; + end; + PMFActivate=^IMFActivate; + + MFT_OUTPUT_DATA_BUFFER=packed record + dwStreamID: Cardinal; + pSample: IMFSample; + dwStatus: Cardinal; + pEvents: IMFCollection; + end; + PMFT_OUTPUT_DATA_BUFFER=^MFT_OUTPUT_DATA_BUFFER; + + IMFTransform=interface(IUnknown) + ['{bf94c121-5b05-4e6f-8000-ba598961414d}'] + function GetStreamLimits(pdwInputMinimum,pdwInputMaximum,pdwOutputMinimum,pdwOutputMaximum: PCardinal): LongInt;stdcall; + function GetStreamCount(pcInputStreams,pcOutputStreams: PCardinal): LongInt;stdcall; + function GetStreamIDs(dwInputIDArraySize: Cardinal;pdwInputIDs: PCardinal;dwOutputIDArraySize: Cardinal;pdwOutputIDs: PCardinal): LongInt;stdcall; + function GetInputStreamInfo(dwInputStreamID: Cardinal;pStreamInfo: PCardinal): LongInt;stdcall; + function GetOutputStreamInfo(dwOutputStreamID: Cardinal;pStreamInfo: PMFT_OUTPUT_STREAM_INFO): LongInt;stdcall; + function GetAttributes(pAttributes: PMFAttributes): LongInt;stdcall; + function GetInputStreamAttributes(dwInputStreamID: Cardinal;pAttributes: PMFAttributes): LongInt;stdcall; + function GetOutputStreamAttributes(dwOutputStreamID: Cardinal;pAttributes: PMFAttributes): LongInt;stdcall; + function DeleteInputStream(dwStreamID: Cardinal): LongInt;stdcall; + function AddInputStreams(cStreams: Cardinal;adwStreamIDs: PCardinal): LongInt;stdcall; + function GetInputAvailableType(dwInputStreamID,dwTypeIndex: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function GetOutputAvailableType(dwOutputStreamID,dwTypeIndex: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function SetInputType(dwInputStreamID: Cardinal;const pType: IMFMediaType;dwFlags: Cardinal): LongInt;stdcall; + function SetOutputType(dwOutputStreamID: Cardinal;const pType: IMFMediaType;dwFlags: Cardinal): LongInt;stdcall; + function GetInputCurrentType(dwInputStreamID: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function GetOutputCurrentType(dwOutputStreamID: Cardinal;ppType: PMFMediaType): LongInt;stdcall; + function GetInputStatus(dwInputStreamID: Cardinal;pdwFlags: PCardinal): LongInt;stdcall; + function GetOutputStatus(pdwFlags: PCardinal): LongInt;stdcall; + function SetOutputBounds(hnsLowerBound,hnsUpperBound: int64): LongInt;stdcall; + function ProcessEvent(dwInputStreamID: Cardinal;const pEvent: IMFMediaEvent): LongInt;stdcall; + function ProcessMessage(eMessage: Cardinal;ulParam: PCardinal): LongInt;stdcall; + function ProcessInput(dwInputStreamID: Cardinal;const pSample: IMFSample;dwFlags: Cardinal): LongInt;stdcall; + function ProcessOutput(dwFlags,cOutputBufferCount: Cardinal;var pOutputSamples: MFT_OUTPUT_DATA_BUFFER;out pdwStatus: Cardinal): LongInt;stdcall; + end; + PMFTransform=^IMFTransform; + + function StringFromGUID2(const guid: TGUID; psz: PWideChar; cbMax: Integer): Integer; stdcall;external ole32; + function IsEqualGUID(const guid1, guid2: TGUID): Boolean; stdcall;external ole32; + function CoInitializeEx(pvReserved: Pointer; coInit: Longint): LongInt; stdcall;external ole32; + function CoCreateInstance(const clsid: TGUID; unkOuter: IUnknown; dwClsContext: Longint; const iid: TGUID; out pv): HResult; stdcall;external ole32; + procedure CoUninitialize; stdcall;external ole32; + function CoTaskMemAlloc(cb: Longint): Pointer; stdcall;external ole32; + function MFCreateSinkWriterFromURL(pwszOutputURL: PWideChar;const pByteStream: IMFByteStream;const pAttributes: IMFAttributes;out ppSinkWriter: IMFSinkWriter): LongInt;stdcall;external mfreadwrite; + function MFGetSupportedMimeTypes(pPropVarMimeTypeArray: PVARIANT): LongInt;stdcall;external mfdll; + function MFCreateTranscodeTopology(const pSrc: IMFMediaSource;const pwszOutputFilePath: PWideChar;const pProfile: IMFTranscodeProfile;out ppTranscodeTopo: IMFTopology): LongInt;stdcall;external mfdll; + function MFCreateTranscodeProfile(ppTranscodeProfile: PMFTranscodeProfile): LongInt;stdcall;external mfdll; + function MFCreateMediaSession(const pConfiguration: IMFAttributes;ppMediaSession: PMFMediaSession): LongInt;stdcall;external mfdll; + function MFCreateMFByteStreamOnStream(const pStream: IStream;ppByteStream: PMFByteStream): LongInt;stdcall;external mfplat; + function MFStartup(Version,dwFlags: Cardinal): LongInt;stdcall;external mfplat; + function MFShutdown: LongInt;stdcall;external mfplat; + function MFTEnumEx(guidCategory: TGUID;Flags: Cardinal;const pInputType,pOutputType: MFT_REGISTER_TYPE_INFO;var pppMFTActivate;out pnumMFTActivate: Cardinal): LongInt;stdcall;external mfplat; + function MFCreateMemoryBuffer(cbMaxLength: Cardinal;ppBuffer: PMFMediaBuffer): LongInt;stdcall;external mfplat; + function MFCreateMediaType(out ppMFType: IMFMediaType): LongInt;stdcall;external mfplat; + function MFCreateSample(out ppIMFSample: IMFSample): LongInt;stdcall;external mfplat; + function MFCreateSourceResolver(out ppISourceResolver: IMFSourceResolver): LongInt;stdcall;external mfplat; + function MFCreateAttributes(ppMFAttributes: PMFAttributes;cInitialSize: Cardinal): LongInt;stdcall;external mfplat; + function MFCreateStreamDescriptor(dwStreamIdentifier,cMediaTypes: Cardinal;apMediaTypes: PMFMediaType;ppDescriptor: PMFStreamDescriptor): LongInt;stdcall;external mfplat; + function MFCreatePresentationDescriptor(cStreamDescriptors: Cardinal;apStreamDescriptors: PMFStreamDescriptor;ppPresentationDescriptor: PMFPresentationDescriptor): LongInt;stdcall;external mfplat; + +implementation + +end. diff --git a/OpenGL.pas b/OpenGL.pas new file mode 100644 index 0000000..8e9cd73 --- /dev/null +++ b/OpenGL.pas @@ -0,0 +1,8655 @@ +unit OpenGL; + +interface +// generell options +{$H+,O+,X+} +{$DEFINE DGL_WIN} + +uses + Windows; + +const + OpenGL32='OpenGL32.dll'; + +type + GLenum = Cardinal; + GLboolean = BYTEBOOL; + GLbitfield = Cardinal; + GLbyte = Shortint; + GLshort = SmallInt; + GLint = Integer; + GLsizei = Integer; + GLubyte = Byte; + GLushort = Word; + GLuint = Cardinal; + GLfloat = Single; + GLclampf = Single; + GLdouble = Double; + GLclampd = Double; + GLvoid = Pointer; + GLint64 = Int64; + GLuint64 = UInt64; + + TGLenum = GLenum; + TGLboolean = GLboolean; + TGLbitfield = GLbitfield; + TGLbyte = GLbyte; + TGLshort = GLshort; + TGLint = GLint; + TGLsizei = GLsizei; + TGLubyte = GLubyte; + TGLushort = GLushort; + TGLuint = GLuint; + TGLfloat = GLfloat; + TGLclampf = GLclampf; + TGLdouble = GLdouble; + TGLclampd = GLclampd; + TGLvoid = GLvoid; + TGLint64 = GLint64; + TGLuint64 = GLuint64; + + PGLboolean = ^GLboolean; + PGLbyte = ^GLbyte; + PGLshort = ^GLshort; + PGLint = ^GLint; + PGLsizei = ^GLsizei; + PGLubyte = ^GLubyte; + PGLushort = ^GLushort; + PGLuint = ^GLuint; + PGLclampf = ^GLclampf; + PGLfloat = ^GLfloat; + PGLdouble = ^GLdouble; + PGLclampd = ^GLclampd; + PGLenum = ^GLenum; + PGLvoid = Pointer; + PPGLvoid = ^PGLvoid; + PGLint64 = ^GLint64; + PGLuint64 = ^GLuint64; + + // GL_NV_half_float + GLhalfNV = WORD; + TGLhalfNV = GLhalfNV; + PGLhalfNV = ^GLhalfNV; + + // GL_ARB_shader_objects + PGLHandleARB = ^GLHandleARB; + GLHandleARB = Integer; + GLcharARB = AnsiChar; + PGLcharARB = PAnsiChar; + PPGLcharARB = ^PGLcharARB; + + // GL_VERSION_1_5 + GLintptr = GLint; + PGLintptr = ^GLintptr; + GLsizeiptr = GLsizei; + + // GL_ARB_vertex_buffer_object + GLintptrARB = GLint; + GLsizeiptrARB = GLsizei; + + // GL_VERSION_2_0 + GLHandle = Integer; + PGLchar = PAnsiChar; + PPGLchar = ^PGLChar; + + // GL_EXT_timer_query + GLint64EXT = Int64; + TGLint64EXT = GLint64EXT; + PGLint64EXT = ^GLint64EXT; + + GLuint64EXT = GLuint64; + TGLuint64EXT = GLuint64EXT; + PGLuint64EXT = ^GLuint64EXT; + + // WGL_ARB_pbuffer + HPBUFFERARB = THandle; + + // WGL_EXT_pbuffer + HPBUFFEREXT = THandle; + + // WGL_NV_present_video + PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV; + HVIDEOOUTPUTDEVICENV = THandle; + + // WGL_NV_video_output + PHPVIDEODEV = ^HPVIDEODEV; + HPVIDEODEV = THandle; + + // WGL_NV_gpu_affinity + PHPGPUNV = ^HPGPUNV; + PHGPUNV = ^HGPUNV; + + // WGL_NV_video_capture + HVIDEOINPUTDEVICENV = THandle; + PHVIDEOINPUTDEVICENV = ^HVIDEOINPUTDEVICENV; + + HPGPUNV = THandle; + HGPUNV = THandle; + + // GL_ARB_sync + GLsync = Pointer; + + // GL_ARB_cl_event + { These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event } + _cl_context = record end; + _cl_event = record end; + p_cl_context = ^_cl_context; + p_cl_event = ^_cl_event; + + // GL_ARB_compute_variable_group_size + TglDispatchComputeGroupSizeARB = procedure (num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint; group_size_x : GLuint; group_size_y : GLuint; group_size_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_debug_output + TglDebugProcARB = procedure (source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_debug_output + TglDebugProcAMD = procedure (id: GLuint; category: GLenum; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_KHR_debug (4.3) + TglDebugProc = procedure(source : GLEnum; type_ : GLEnum; id : GLUInt; severity : GLUInt; length : GLsizei; const message_ : PGLCHar; userParam : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vdpau_interop + GLvdpauSurfaceNV = GLintptr; + PGLvdpauSurfaceNV = ^GLvdpauSurfaceNV; + + // Datatypes corresponding to GL's types TGL(name)(type)(count) + TGLVectorub2 = array[0..1] of GLubyte; + TGLVectori2 = array[0..1] of GLint; + TGLVectorf2 = array[0..1] of GLfloat; + TGLVectord2 = array[0..1] of GLdouble; + TGLVectorp2 = array[0..1] of Pointer; + + TGLVectorub3 = array[0..2] of GLubyte; + TGLVectori3 = array[0..2] of GLint; + TGLVectorf3 = array[0..2] of GLfloat; + TGLVectord3 = array[0..2] of GLdouble; + TGLVectorp3 = array[0..2] of Pointer; + + TGLVectorub4 = array[0..3] of GLubyte; + TGLVectori4 = array[0..3] of GLint; + TGLVectorf4 = array[0..3] of GLfloat; + TGLVectord4 = array[0..3] of GLdouble; + TGLVectorp4 = array[0..3] of Pointer; + + TGLArrayf4 = TGLVectorf4; + TGLArrayf3 = TGLVectorf3; + TGLArrayd3 = TGLVectord3; + TGLArrayi4 = TGLVectori4; + TGLArrayp4 = TGLVectorp4; + + TGlMatrixub3 = array[0..2, 0..2] of GLubyte; + TGlMatrixi3 = array[0..2, 0..2] of GLint; + TGLMatrixf3 = array[0..2, 0..2] of GLfloat; + TGLMatrixd3 = array[0..2, 0..2] of GLdouble; + + TGlMatrixub4 = array[0..3, 0..3] of GLubyte; + TGlMatrixi4 = array[0..3, 0..3] of GLint; + TGLMatrixf4 = array[0..3, 0..3] of GLfloat; + TGLMatrixd4 = array[0..3, 0..3] of GLdouble; + + TGLVector3f = TGLVectorf3; + + // Datatypes corresponding to OpenGL12.pas for easy porting + TVector3f = TGLVectorf3; + TVector3d = TGLVectord3; + + TVector4i = TGLVectori4; + TVector4f = TGLVectorf4; + TVector4p = TGLVectorp4; + + TMatrix4f = TGLMatrixf4; + TMatrix4d = TGLMatrixd4; + + PGLMatrixd4 = ^TGLMatrixd4; + PVector4i = ^TVector4i; + + + +{$IFDEF FPC} + TRect = packed record + Left, Top, Right, Bottom: Longint; + end; +{$ENDIF} + + + PGPU_DEVICE = ^GPU_DEVICE; + GPU_DEVICE = record + cb: DWORD; + DeviceName: array [0..31] of AnsiChar; + DeviceString: array [0..127] of AnsiChar; + Flags: DWORD; + rcVirtualScreen: TRect; + end; + + +type +{$IFDEF FPC} + {$IFDEF DGL_WIN} + PWGLSwap = ^TWGLSwap; + {$EXTERNALSYM _WGLSWAP} + _WGLSWAP = packed record + hdc: HDC; + uiFlags: UINT; + end; + + TWGLSwap = _WGLSWAP; + {$EXTERNALSYM WGLSWAP} + WGLSWAP = _WGLSWAP; + + {$ENDIF} +{$ENDIF} + + // GLU types + TGLUNurbs = record + end; + TGLUQuadric = record + end; + TGLUTesselator = record + end; + PGLUNurbs = ^TGLUNurbs; + PGLUQuadric = ^TGLUQuadric; + PGLUTesselator = ^TGLUTesselator; + // backwards compatibility + TGLUNurbsObj = TGLUNurbs; + TGLUQuadricObj = TGLUQuadric; + TGLUTesselatorObj = TGLUTesselator; + TGLUTriangulatorObj = TGLUTesselator; + PGLUNurbsObj = PGLUNurbs; + PGLUQuadricObj = PGLUQuadric; + PGLUTesselatorObj = PGLUTesselator; + PGLUTriangulatorObj = PGLUTesselator; + + // GLUQuadricCallback + TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GLUTessCallback + TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GLUNurbsCallback + TGLUNurbsErrorProc = procedure(ErrorCode: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + //WIGGLE + function wglGetProcAddress(ProcName: PAnsiChar): Pointer; stdcall;external OPenGL32; + function wglCopyContext(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;external OPenGL32; + function wglCreateContext(DC: HDC): HGLRC; stdcall;external OPenGL32; + function wglCreateLayerContext(p1: HDC; p2: Integer): HGLRC; stdcall;external OPenGL32; + function wglDeleteContext(p1: HGLRC): BOOL; stdcall;external OPenGL32; + function wglDescribeLayerPlane(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall;external OPenGL32; + function wglGetCurrentContext: HGLRC; stdcall;external OPenGL32; + function wglGetCurrentDC: HDC; stdcall;external OPenGL32; + function wglGetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;external OPenGL32; + function wglMakeCurrent(DC: HDC; p2: HGLRC): BOOL; stdcall;external OPenGL32; + function wglRealizeLayerPalette(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;external OPenGL32; + function wglSetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;external OPenGL32; + function wglShareLists(p1, p2: HGLRC): BOOL; stdcall;external OPenGL32; + function wglSwapLayerBuffers(p1: HDC; p2: Cardinal): BOOL; stdcall;external OPenGL32; + function wglSwapMultipleBuffers(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall;external OPenGL32; + function wglUseFontBitmapsA(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;external OPenGL32; + function wglUseFontBitmapsW(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;external OPenGL32; + function wglUseFontBitmaps(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;external OPenGL32; + function wglUseFontOutlinesA(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;external OPenGL32; + function wglUseFontOutlinesW(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;external OPenGL32; + function wglUseFontOutlines(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;external OPenGL32; + + //DEPRECATED + procedure glAccum(op: GLenum; value: GLfloat);stdcall;external OPenGL32; + procedure glAlphaFunc(func: GLenum; ref: GLclampf);stdcall; external OPenGL32; + function glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean;stdcall; external OPenGL32; + procedure glArrayElement(i: GLint);stdcall; external OPenGL32; + procedure glBegin(mode: GLenum);stdcall; external OPenGL32; + procedure glBitmap(width: GLsizei; height: GLsizei; xorig: GLfloat; yorig: GLfloat; xmove: GLfloat; ymove: GLfloat; const bitmap: PGLubyte);stdcall; external OPenGL32; + procedure glCallList(list: GLuint);stdcall; external OPenGL32; + procedure glCallLists(n: GLsizei; _type: GLenum; const lists: PGLvoid);stdcall; external OPenGL32; + procedure glClearAccum(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat);stdcall; external OPenGL32; + procedure glClearIndex(c: GLfloat);stdcall; external OPenGL32; + procedure glClipPlane(plane: GLenum; const equation: PGLdouble);stdcall; external OPenGL32; + procedure glColor3b(red: GLbyte; green: GLbyte; blue: GLbyte);stdcall; external OPenGL32; + procedure glColor3bv(const v: PGLbyte);stdcall; external OPenGL32; + procedure glColor3d(red: GLdouble; green: GLdouble; blue: GLdouble);stdcall; external OPenGL32; + procedure glColor3dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glColor3f(red: GLfloat; green: GLfloat; blue: GLfloat);stdcall; external OPenGL32; + procedure glColor3fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glColor3i(red: GLint; green: GLint; blue: GLint);stdcall; external OPenGL32; + procedure glColor3iv(const v: PGLint);stdcall; external OPenGL32; + procedure glColor3s(red: GLshort; green: GLshort; blue: GLshort);stdcall; external OPenGL32; + procedure glColor3sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glColor3ub(red: GLubyte; green: GLubyte; blue: GLubyte);stdcall; external OPenGL32; + procedure glColor3ubv(const v: PGLubyte);stdcall; external OPenGL32; + procedure glColor3ui(red: GLuint; green: GLuint; blue: GLuint);stdcall; external OPenGL32; + procedure glColor3uiv(const v: PGLuint);stdcall; external OPenGL32; + procedure glColor3us(red: GLushort; green: GLushort; blue: GLushort);stdcall; external OPenGL32; + procedure glColor3usv(const v: PGLushort);stdcall; external OPenGL32; + procedure glColor4b(red: GLbyte; green: GLbyte; blue: GLbyte; alpha: GLbyte);stdcall; external OPenGL32; + procedure glColor4bv(const v: PGLbyte);stdcall; external OPenGL32; + procedure glColor4d(red: GLdouble; green: GLdouble; blue: GLdouble; alpha: GLdouble);stdcall; external OPenGL32; + procedure glColor4dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glColor4f(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat);stdcall; external OPenGL32; + procedure glColor4fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glColor4i(red: GLint; green: GLint; blue: GLint; alpha: GLint);stdcall; external OPenGL32; + procedure glColor4iv(const v: PGLint);stdcall; external OPenGL32; + procedure glColor4s(red: GLshort; green: GLshort; blue: GLshort; alpha: GLshort);stdcall; external OPenGL32; + procedure glColor4sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glColor4ub(red: GLubyte; green: GLubyte; blue: GLubyte; alpha: GLubyte);stdcall; external OPenGL32; + procedure glColor4ubv(const v: PGLubyte);stdcall; external OPenGL32; + procedure glColor4ui(red: GLuint; green: GLuint; blue: GLuint; alpha: GLuint);stdcall; external OPenGL32; + procedure glColor4uiv(const v: PGLuint);stdcall; external OPenGL32; + procedure glColor4us(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort);stdcall; external OPenGL32; + procedure glColor4usv(const v: PGLushort);stdcall; external OPenGL32; + procedure glColorMaterial(face: GLenum; mode: GLenum);stdcall; external OPenGL32; + procedure glColorPointer(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + procedure glCopyPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; _type: GLenum);stdcall; external OPenGL32; + procedure glDeleteLists(list: GLuint; range: GLsizei);stdcall; external OPenGL32; + procedure glDisableClientState(_array: GLenum);stdcall; external OPenGL32; + procedure glDrawPixels(width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid);stdcall; external OPenGL32; + procedure glEdgeFlag(flag: GLboolean);stdcall; external OPenGL32; + procedure glEdgeFlagPointer(stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + procedure glEdgeFlagv(const flag: PGLboolean);stdcall; external OPenGL32; + procedure glEnableClientState(_array: GLenum);stdcall; external OPenGL32; + procedure glEnd();stdcall; external OPenGL32; + procedure glEndList();stdcall; external OPenGL32; + procedure glEvalCoord1d(u: GLdouble);stdcall; external OPenGL32; + procedure glEvalCoord1dv(const u: PGLdouble);stdcall; external OPenGL32; + procedure glEvalCoord1f(u: GLfloat);stdcall; external OPenGL32; + procedure glEvalCoord1fv(const u: PGLfloat);stdcall; external OPenGL32; + procedure glEvalCoord2d(u: GLdouble; v: GLdouble);stdcall; external OPenGL32; + procedure glEvalCoord2dv(const u: PGLdouble);stdcall; external OPenGL32; + procedure glEvalCoord2f(u: GLfloat; v: GLfloat);stdcall; external OPenGL32; + procedure glEvalCoord2fv(const u: PGLfloat);stdcall; external OPenGL32; + procedure glEvalMesh1(mode: GLenum; i1: GLint; i2: GLint);stdcall; external OPenGL32; + procedure glEvalMesh2(mode: GLenum; i1: GLint; i2: GLint; j1: GLint; j2: GLint);stdcall; external OPenGL32; + procedure glEvalPoint1(i: GLint);stdcall; external OPenGL32; + procedure glEvalPoint2(i: GLint; j: GLint);stdcall; external OPenGL32; + procedure glFeedbackBuffer(size: GLsizei; _type: GLenum; buffer: PGLfloat);stdcall; external OPenGL32; + procedure glFogf(pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glFogfv(pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glFogi(pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glFogiv(pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glFrustum(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble);stdcall; external OPenGL32; + procedure glFrontFace(mode: GLenum);stdcall; external OPenGL32; + function glGenLists(range: GLsizei): GLuint;stdcall; external OPenGL32; + procedure glGetClipPlane(plane: GLenum; equation: PGLdouble);stdcall; external OPenGL32; + procedure glGetLightfv(light: GLenum; pname: GLenum; params: PGLfloat);stdcall; external OPenGL32; + procedure glGetLightiv(light: GLenum; pname: GLenum; params: PGLint);stdcall; external OPenGL32; + procedure glGetMapdv(target: GLenum; query: GLenum; v: PGLdouble);stdcall; external OPenGL32; + procedure glGetMapfv(target: GLenum; query: GLenum; v: PGLfloat);stdcall; external OPenGL32; + procedure glGetMapiv(target: GLenum; query: GLenum; v: PGLint);stdcall; external OPenGL32; + procedure glGetMaterialfv(face: GLenum; pname: GLenum; params: PGLfloat);stdcall; external OPenGL32; + procedure glGetMaterialiv(face: GLenum; pname: GLenum; params: PGLint);stdcall; external OPenGL32; + procedure glGetPixelMapfv(map: GLenum; values: PGLfloat);stdcall; external OPenGL32; + procedure glGetPixelMapuiv(map: GLenum; values: PGLuint);stdcall; external OPenGL32; + procedure glGetPixelMapusv(map: GLenum; values: PGLushort);stdcall; external OPenGL32; + procedure glGetPolygonStipple(mask: PGLubyte);stdcall; external OPenGL32; + procedure glGetTexEnvfv(target: GLenum; pname: GLenum; params: PGLfloat);stdcall; external OPenGL32; + procedure glGetTexEnviv(target: GLenum; pname: GLenum; params: PGLint);stdcall; external OPenGL32; + procedure glGetTexGendv(coord: GLenum; pname: GLenum; params: PGLdouble);stdcall; external OPenGL32; + procedure glGetTexGenfv(coord: GLenum; pname: GLenum; params: PGLfloat);stdcall; external OPenGL32; + procedure glGetTexGeniv(coord: GLenum; pname: GLenum; params: PGLint);stdcall; external OPenGL32; + procedure glIndexMask(mask: GLuint);stdcall; external OPenGL32; + procedure glIndexPointer(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + procedure glIndexd(c: GLdouble);stdcall; external OPenGL32; + procedure glIndexdv(const c: PGLdouble);stdcall; external OPenGL32; + procedure glIndexf(c: GLfloat);stdcall; external OPenGL32; + procedure glIndexfv(const c: PGLfloat);stdcall; external OPenGL32; + procedure glIndexi(c: GLint);stdcall; external OPenGL32; + procedure glIndexiv(const c: PGLint);stdcall; external OPenGL32; + procedure glIndexs(c: GLshort);stdcall; external OPenGL32; + procedure glIndexsv(const c: PGLshort);stdcall; external OPenGL32; + procedure glIndexub(c: GLubyte);stdcall; external OPenGL32; + procedure glIndexubv(const c: PGLubyte);stdcall; external OPenGL32; + procedure glInitNames;stdcall; external OPenGL32; + procedure glInterleavedArrays(format: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + function glIsList(list: GLuint): GLboolean;stdcall; external OPenGL32; + function glIsTexture(texture: GLuint): GLboolean;stdcall; external OPenGL32; + procedure glLightModelf(pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glLightModelfv(pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glLightModeli(pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glLightModeliv(pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glLightf(light: GLenum; pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glLightfv(light: GLenum; pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glLighti(light: GLenum; pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glLightiv(light: GLenum; pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glLineStipple(factor: GLint; pattern: GLushort);stdcall; external OPenGL32; + procedure glListBase(base: GLuint);stdcall; external OPenGL32; + procedure glLoadIdentity;stdcall; external OPenGL32; + procedure glLoadMatrixd(const m: PGLdouble);stdcall; external OPenGL32; + procedure glLoadMatrixf(const m: PGLfloat);stdcall; external OPenGL32; + procedure glLoadName(name: GLuint);stdcall; external OPenGL32; + procedure glMap1d(target: GLenum; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble);stdcall; external OPenGL32; + procedure glMap1f(target: GLenum; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat);stdcall; external OPenGL32; + procedure glMap2d(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble);stdcall; external OPenGL32; + procedure glMap2f(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: PGLfloat);stdcall; external OPenGL32; + procedure glMapGrid1d(un: GLint; u1: GLdouble; u2: GLdouble);stdcall; external OPenGL32; + procedure glMapGrid1f(un: GLint; u1: GLfloat; u2: GLfloat);stdcall; external OPenGL32; + procedure glMapGrid2d(un: GLint; u1: GLdouble; u2: GLdouble; vn: GLint; v1: GLdouble; v2: GLdouble);stdcall; external OPenGL32; + procedure glMapGrid2f(un: GLint; u1: GLfloat; u2: GLfloat; vn: GLint; v1: GLfloat; v2: GLfloat);stdcall; external OPenGL32; + procedure glMaterialf(face: GLenum; pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glMaterialfv(face: GLenum; pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glMateriali(face: GLenum; pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glMaterialiv(face: GLenum; pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glMatrixMode(mode: GLenum);stdcall; external OPenGL32; + procedure glMultMatrixd(const m: PGLdouble);stdcall; external OPenGL32; + procedure glMultMatrixf(const m: PGLfloat);stdcall; external OPenGL32; + procedure glNewList(list: GLuint; mode: GLenum);stdcall; external OPenGL32; + procedure glNormal3b(nx: GLbyte; ny: GLbyte; nz: GLbyte);stdcall; external OPenGL32; + procedure glNormal3bv(const v: PGLbyte);stdcall; external OPenGL32; + procedure glNormal3d(nx: GLdouble; ny: GLdouble; nz: GLdouble);stdcall; external OPenGL32; + procedure glNormal3dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glNormal3f(nx: GLfloat; ny: GLfloat; nz: GLfloat);stdcall; external OPenGL32; + procedure glNormal3fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glNormal3i(nx: GLint; ny: GLint; nz: GLint);stdcall; external OPenGL32; + procedure glNormal3iv(const v: PGLint);stdcall; external OPenGL32; + procedure glNormal3s(nx: GLshort; ny: GLshort; nz: GLshort);stdcall; external OPenGL32; + procedure glNormal3sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glNormalPointer(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + procedure glOrtho(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble);stdcall; external OPenGL32; + procedure glPassThrough(token: GLfloat);stdcall; external OPenGL32; + procedure glPixelMapfv(map: GLenum; mapsize: GLsizei; const values: PGLfloat);stdcall; external OPenGL32; + procedure glPixelMapuiv(map: GLenum; mapsize: GLsizei; const values: PGLuint);stdcall; external OPenGL32; + procedure glPixelMapusv(map: GLenum; mapsize: GLsizei; const values: PGLushort);stdcall; external OPenGL32; + procedure glPixelTransferf(pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glPixelTransferi(pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glPixelZoom(xfactor: GLfloat; yfactor: GLfloat);stdcall; external OPenGL32; + procedure glPolygonStipple(const mask: PGLubyte);stdcall; external OPenGL32; + procedure glPopAttrib();stdcall; external OPenGL32; + procedure glPopClientAttrib();stdcall; external OPenGL32; + procedure glPopMatrix();stdcall; external OPenGL32; + procedure glPopName();stdcall; external OPenGL32; + procedure glPrioritizeTextures(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf);stdcall; external OPenGL32; + procedure glPushAttrib(mask: GLbitfield);stdcall; external OPenGL32; + procedure glPushClientAttrib(mask: GLbitfield);stdcall; external OPenGL32; + procedure glPushMatrix();stdcall; external OPenGL32; + procedure glPushName(name: GLuint);stdcall; external OPenGL32; + procedure glRasterPos2d(x: GLdouble; y: GLdouble);stdcall; external OPenGL32; + procedure glRasterPos2dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glRasterPos2f(x: GLfloat; y: GLfloat);stdcall; external OPenGL32; + procedure glRasterPos2fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glRasterPos2i(x: GLint; y: GLint);stdcall; external OPenGL32; + procedure glRasterPos2iv(const v: PGLint);stdcall; external OPenGL32; + procedure glRasterPos2s(x: GLshort; y: GLshort);stdcall; external OPenGL32; + procedure glRasterPos2sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glRasterPos3d(x: GLdouble; y: GLdouble; z: GLdouble);stdcall; external OPenGL32; + procedure glRasterPos3dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glRasterPos3f(x: GLfloat; y: GLfloat; z: GLfloat);stdcall; external OPenGL32; + procedure glRasterPos3fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glRasterPos3i(x: GLint; y: GLint; z: GLint);stdcall; external OPenGL32; + procedure glRasterPos3iv(const v: PGLint);stdcall; external OPenGL32; + procedure glRasterPos3s(x: GLshort; y: GLshort; z: GLshort);stdcall; external OPenGL32; + procedure glRasterPos3sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glRasterPos4d(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble);stdcall; external OPenGL32; + procedure glRasterPos4dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glRasterPos4f(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat);stdcall; external OPenGL32; + procedure glRasterPos4fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glRasterPos4i(x: GLint; y: GLint; z: GLint; w: GLint);stdcall; external OPenGL32; + procedure glRasterPos4iv(const v: PGLint);stdcall; external OPenGL32; + procedure glRasterPos4s(x: GLshort; y: GLshort; z: GLshort; w: GLshort);stdcall; external OPenGL32; + procedure glRasterPos4sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glRectd(x1: GLdouble; y1: GLdouble; x2: GLdouble; y2: GLdouble);stdcall; external OPenGL32; + procedure glRectdv(const v1: PGLdouble; const v2: PGLdouble);stdcall; external OPenGL32; + procedure glRectf(x1: GLfloat; y1: GLfloat; x2: GLfloat; y2: GLfloat);stdcall; external OPenGL32; + procedure glRectfv(const v1: PGLfloat; const v2: PGLfloat);stdcall; external OPenGL32; + procedure glRecti(x1: GLint; y1: GLint; x2: GLint; y2: GLint);stdcall; external OPenGL32; + procedure glRectiv(const v1: PGLint; const v2: PGLint);stdcall; external OPenGL32; + procedure glRects(x1: GLshort; y1: GLshort; x2: GLshort; y2: GLshort);stdcall; external OPenGL32; + procedure glRectsv(const v1: PGLshort; const v2: PGLshort);stdcall; external OPenGL32; + function glRenderMode(mode: GLenum): GLint;stdcall; external OPenGL32; + procedure glRotated(angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble);stdcall; external OPenGL32; + procedure glRotatef(angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat);stdcall; external OPenGL32; + procedure glScaled(x: GLdouble; y: GLdouble; z: GLdouble);stdcall; external OPenGL32; + procedure glScalef(x: GLfloat; y: GLfloat; z: GLfloat);stdcall; external OPenGL32; + procedure glSelectBuffer(size: GLsizei; buffer: PGLuint);stdcall; external OPenGL32; + procedure glShadeModel(mode: GLenum);stdcall; external OPenGL32; + procedure glTexCoord1d(s: GLdouble);stdcall; external OPenGL32; + procedure glTexCoord1dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glTexCoord1f(s: GLfloat);stdcall; external OPenGL32; + procedure glTexCoord1fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glTexCoord1i(s: GLint);stdcall; external OPenGL32; + procedure glTexCoord1iv(const v: PGLint);stdcall; external OPenGL32; + procedure glTexCoord1s(s: GLshort);stdcall; external OPenGL32; + procedure glTexCoord1sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glTexCoord2d(s: GLdouble; t: GLdouble);stdcall; external OPenGL32; + procedure glTexCoord2dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glTexCoord2f(s: GLfloat; t: GLfloat);stdcall; external OPenGL32; + procedure glTexCoord2fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glTexCoord2i(s: GLint; t: GLint);stdcall; external OPenGL32; + procedure glTexCoord2iv(const v: PGLint);stdcall; external OPenGL32; + procedure glTexCoord2s(s: GLshort; t: GLshort);stdcall; external OPenGL32; + procedure glTexCoord2sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glTexCoord3d(s: GLdouble; t: GLdouble; r: GLdouble);stdcall; external OPenGL32; + procedure glTexCoord3dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glTexCoord3f(s: GLfloat; t: GLfloat; r: GLfloat);stdcall; external OPenGL32; + const + GL_BUFFER_SIZE = $8764; + GL_BUFFER_USAGE = $8765; + GL_QUERY_COUNTER_BITS = $8864; + GL_CURRENT_QUERY = $8865; + GL_QUERY_RESULT = $8866; + GL_QUERY_RESULT_AVAILABLE = $8867; + GL_ARRAY_BUFFER = $8892; + GL_ELEMENT_ARRAY_BUFFER = $8893; + GL_ARRAY_BUFFER_BINDING = $8894; + GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895; + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F; + GL_READ_ONLY = $88B8; + GL_WRITE_ONLY = $88B9; + GL_READ_WRITE = $88BA; + GL_BUFFER_ACCESS = $88BB; + GL_BUFFER_MAPPED = $88BC; + GL_BUFFER_MAP_POINTER = $88BD; + GL_STREAM_DRAW = $88E0; + GL_STREAM_READ = $88E1; + GL_STREAM_COPY = $88E2; + GL_STATIC_DRAW = $88E4; + GL_STATIC_READ = $88E5; + GL_STATIC_COPY = $88E6; + GL_DYNAMIC_DRAW = $88E8; + GL_DYNAMIC_READ = $88E9; + GL_DYNAMIC_COPY = $88EA; + GL_SAMPLES_PASSED = $8914; + GL_VERTEX_ARRAY_BUFFER_BINDING = $8896; + GL_NORMAL_ARRAY_BUFFER_BINDING = $8897; + GL_COLOR_ARRAY_BUFFER_BINDING = $8898; + GL_INDEX_ARRAY_BUFFER_BINDING = $8899; + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A; + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B; + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C; + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D; + GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E; + GL_FOG_COORD_SRC = $8450; + GL_FOG_COORD = $8451; + GL_CURRENT_FOG_COORD = $8453; + GL_FOG_COORD_ARRAY_TYPE = $8454; + GL_FOG_COORD_ARRAY_STRIDE = $8455; + GL_FOG_COORD_ARRAY_POINTER = $8456; + GL_FOG_COORD_ARRAY = $8457; + GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D; + GL_SRC0_RGB = $8580; + GL_SRC1_RGB = $8581; + GL_SRC2_RGB = $8582; + GL_SRC0_ALPHA = $8588; + GL_SRC1_ALPHA = $8589; + GL_SRC2_ALPHA = $858A; + + procedure glTexCoord3i(s: GLint; t: GLint; r: GLint);stdcall; external OPenGL32; + procedure glTexCoord3iv(const v: PGLint);stdcall; external OPenGL32; + procedure glTexCoord3s(s: GLshort; t: GLshort; r: GLshort);stdcall; external OPenGL32; + procedure glTexCoord3sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glTexCoord4d(s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble);stdcall; external OPenGL32; + procedure glTexCoord4dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glTexCoord4f(s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat);stdcall; external OPenGL32; + procedure glTexCoord4fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glTexCoord4i(s: GLint; t: GLint; r: GLint; q: GLint);stdcall; external OPenGL32; + procedure glTexCoord4iv(const v: PGLint);stdcall; external OPenGL32; + procedure glTexCoord4s(s: GLshort; t: GLshort; r: GLshort; q: GLshort);stdcall; external OPenGL32; + procedure glTexCoord4sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glTexCoordPointer(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + procedure glTexEnvf(target: GLenum; pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glTexEnvfv(target: GLenum; pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glTexEnvi(target: GLenum; pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glTexEnviv(target: GLenum; pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glTexGend(coord: GLenum; pname: GLenum; param: GLdouble);stdcall; external OPenGL32; + procedure glTexGendv(coord: GLenum; pname: GLenum; const params: PGLdouble);stdcall; external OPenGL32; + procedure glTexGenf(coord: GLenum; pname: GLenum; param: GLfloat);stdcall; external OPenGL32; + procedure glTexGenfv(coord: GLenum; pname: GLenum; const params: PGLfloat);stdcall; external OPenGL32; + procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint);stdcall; external OPenGL32; + procedure glTexGeniv(coord: GLenum; pname: GLenum; const params: PGLint);stdcall; external OPenGL32; + procedure glTranslated(x: GLdouble; y: GLdouble; z: GLdouble);stdcall; external OPenGL32; + procedure glTranslatef(x: GLfloat; y: GLfloat; z: GLfloat);stdcall; external OPenGL32; + procedure glVertex2d(x: GLdouble; y: GLdouble);stdcall; external OPenGL32; + procedure glVertex2dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glVertex2f(x: GLfloat; y: GLfloat);stdcall; external OPenGL32; + procedure glVertex2fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glVertex2i(x: GLint; y: GLint);stdcall; external OPenGL32; + procedure glVertex2iv(const v: PGLint);stdcall; external OPenGL32; + procedure glVertex2s(x: GLshort; y: GLshort);stdcall; external OPenGL32; + procedure glVertex2sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glVertex3d(x: GLdouble; y: GLdouble; z: GLdouble);stdcall; external OPenGL32; + procedure glVertex3dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glVertex3f(x: GLfloat; y: GLfloat; z: GLfloat);stdcall; external OPenGL32; + procedure glVertex3fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glVertex3i(x: GLint; y: GLint; z: GLint);stdcall; external OPenGL32; + procedure glVertex3iv(const v: PGLint);stdcall; external OPenGL32; + procedure glVertex3s(x: GLshort; y: GLshort; z: GLshort);stdcall; external OPenGL32; + procedure glVertex3sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glVertex4d(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble);stdcall; external OPenGL32; + procedure glVertex4dv(const v: PGLdouble);stdcall; external OPenGL32; + procedure glVertex4f(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat);stdcall; external OPenGL32; + procedure glVertex4fv(const v: PGLfloat);stdcall; external OPenGL32; + procedure glVertex4i(x: GLint; y: GLint; z: GLint; w: GLint);stdcall; external OPenGL32; + procedure glVertex4iv(const v: PGLint);stdcall; external OPenGL32; + procedure glVertex4s(x: GLshort; y: GLshort; z: GLshort; w: GLshort);stdcall; external OPenGL32; + procedure glVertex4sv(const v: PGLshort);stdcall; external OPenGL32; + procedure glVertexPointer(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid);stdcall; external OPenGL32; + + // GL_VERSION_1_0 + procedure glCullFace(mode: GLenum); stdcall;external OpenGL32; + procedure glHint(target: GLenum; mode: GLenum); stdcall;external OpenGL32; + procedure glLineWidth(width: GLfloat); stdcall;external OpenGL32; + procedure glPointSize(size: GLfloat); stdcall;external OpenGL32; + procedure glPolygonMode(face: GLenum; mode: GLenum); stdcall;external OpenGL32; + procedure glScissor(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall;external OpenGL32; + procedure glTexParameterf(target: GLenum; pname: GLenum; param: GLfloat); stdcall;external OpenGL32; + procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); stdcall;external OpenGL32; + procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); stdcall;external OpenGL32; + procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); stdcall;external OpenGL32; + procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); stdcall;external OpenGL32; + procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum;var pixels); stdcall;external OpenGL32; + procedure glDrawBuffer(mode: GLenum); stdcall;external OpenGL32; + procedure glClear(mask: GLbitfield); stdcall;external OpenGL32; + procedure glClearColor(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); stdcall;external OpenGL32; + procedure glClearStencil(s: GLint); stdcall;external OpenGL32; + procedure glClearDepth(depth: GLclampd); stdcall;external OpenGL32; + procedure glStencilMask(mask: GLuint); stdcall;external OpenGL32; + procedure glColorMask(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); stdcall;external OpenGL32; + procedure glDepthMask(flag: GLboolean); stdcall;external OpenGL32; + procedure glDisable(cap: GLenum); stdcall;external OpenGL32; + procedure glEnable(cap: GLenum); stdcall;external OpenGL32; + procedure glFinish; stdcall;external OpenGL32; + procedure glFlush; stdcall;external OpenGL32; + procedure glBlendFunc(sfactor: GLenum; dfactor: GLenum); stdcall;external OpenGL32; + procedure glLogicOp(opcode: GLenum); stdcall;external OpenGL32; + procedure glStencilFunc(func: GLenum; ref: GLint; mask: GLuint); stdcall;external OpenGL32; + procedure glStencilOp(fail: GLenum; zfail: GLenum; zpass: GLenum); stdcall;external OpenGL32; + procedure glDepthFunc(func: GLenum); stdcall;external OpenGL32; + procedure glPixelStoref(pname: GLenum; param: GLfloat); stdcall;external OpenGL32; + procedure glPixelStorei(pname: GLenum; param: GLint); stdcall;external OpenGL32; + procedure glReadBuffer(mode: GLenum); stdcall;external OpenGL32; + procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); stdcall;external OpenGL32; + procedure glGetBooleanv(pname: GLenum; params: PGLboolean); stdcall;external OpenGL32; + procedure glGetDoublev(pname: GLenum; params: PGLdouble); stdcall;external OpenGL32; + function glGetError: GLenum; stdcall;external OpenGL32; + procedure glGetFloatv(pname: GLenum; params: PGLfloat); stdcall;external OpenGL32; + procedure glGetIntegerv(pname: GLenum; params: PGLint); stdcall;external OpenGL32; + function glGetString(name: GLenum): PAnsiChar; stdcall;external OpenGL32; + procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); stdcall;external OpenGL32; + procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); stdcall;external OpenGL32; + procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); stdcall;external OpenGL32; + procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); stdcall;external OpenGL32; + procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); stdcall;external OpenGL32; + function glIsEnabled(cap: GLenum): GLboolean; stdcall;external OpenGL32; + procedure glDepthRange(zNear: GLclampd; zFar: GLclampd); stdcall;external OpenGL32; + procedure glViewport(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall;external OpenGL32; + + // GL_VERSION_1_1 + procedure glDrawArrays(mode: GLenum; first: GLint; count: GLsizei); stdcall;external OpenGL32; + procedure glDrawElements(mode: GLenum; count: GLsizei; _type: GLenum; const indices: PGLvoid); stdcall;external OpenGL32; + procedure glGetPointerv(pname: GLenum; params: PGLvoid); stdcall;external OpenGL32; + procedure glPolygonOffset(factor: GLfloat; units: GLfloat); stdcall;external OpenGL32; + procedure glCopyTexImage1D(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); stdcall;external OpenGL32; + procedure glCopyTexImage2D(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); stdcall;external OpenGL32; + procedure glCopyTexSubImage1D(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); stdcall;external OpenGL32; + procedure glCopyTexSubImage2D(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall;external OpenGL32; + procedure glTexSubImage1D(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); stdcall;external OpenGL32; + procedure glTexSubImage2D(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); stdcall;external OpenGL32; + procedure glBindTexture(target: GLenum; texture: GLuint); stdcall;external OpenGL32; + procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); stdcall;external OpenGL32; + procedure glGenTextures(n: GLsizei;out textures); stdcall;external OpenGL32; + +var + GL_VERSION_1_0, + GL_VERSION_1_1, + GL_VERSION_1_2, + GL_VERSION_1_3, + GL_VERSION_1_4, + GL_VERSION_1_5, + GL_VERSION_2_0, + GL_VERSION_2_1, + GL_VERSION_3_0, + GL_VERSION_3_1, + GL_VERSION_3_2, + GL_VERSION_3_3, + GL_VERSION_4_0, + GL_VERSION_4_1, + GL_VERSION_4_2, + GL_VERSION_4_3, + GL_VERSION_4_4, + GL_VERSION_4_5, + GLU_VERSION_1_1, + GLU_VERSION_1_2, + GLU_VERSION_1_3, + GL_3DFX_multisample, + GL_3DFX_tbuffer, + GL_3DFX_texture_compression_FXT1, + GL_APPLE_client_storage, + GL_APPLE_element_array, + GL_APPLE_fence, + GL_APPLE_specular_vector, + GL_APPLE_transform_hint, + GL_APPLE_vertex_array_object, + GL_APPLE_vertex_array_range, + GL_APPLE_ycbcr_422, + GL_APPLE_texture_range, + GL_APPLE_float_pixels, + GL_APPLE_vertex_program_evaluators, + GL_APPLE_aux_depth_stencil, + GL_APPLE_object_purgeable, + GL_APPLE_row_bytes, + GL_APPLE_rgb_422, + GL_ARB_depth_texture, + GL_ARB_fragment_program, + GL_ARB_imaging, + GL_ARB_matrix_palette, + GL_ARB_multisample, + GL_ARB_multitexture, + GL_ARB_point_parameters, + GL_ARB_shadow, + GL_ARB_shadow_ambient, + GL_ARB_texture_border_clamp, + GL_ARB_texture_compression, + GL_ARB_texture_cube_map, + GL_ARB_texture_env_add, + GL_ARB_texture_env_combine, + GL_ARB_texture_env_crossbar, + GL_ARB_texture_env_dot3, + GL_ARB_texture_mirrored_repeat, + GL_ARB_transpose_matrix, + GL_ARB_vertex_blend, + GL_ARB_vertex_buffer_object, + GL_ARB_vertex_program, + GL_ARB_window_pos, + GL_ARB_shader_objects, + GL_ARB_vertex_shader, + GL_ARB_fragment_shader, + GL_ARB_shading_language_100, + GL_ARB_occlusion_query, + GL_ARB_texture_non_power_of_two, + GL_ARB_point_sprite, + GL_ARB_fragment_program_shadow, + GL_ARB_draw_buffers, + GL_ARB_texture_rectangle, + GL_ARB_color_buffer_float, + GL_ARB_half_float_pixel, + GL_ARB_texture_float, + GL_ARB_pixel_buffer_object, + GL_ARB_depth_buffer_float, + GL_ARB_draw_instanced, + GL_ARB_framebuffer_object, + GL_ARB_framebuffer_sRGB, + GL_ARB_geometry_shader4, + GL_ARB_half_float_vertex, + GL_ARB_instanced_arrays, + GL_ARB_map_buffer_range, + GL_ARB_texture_buffer_object, + GL_ARB_texture_compression_rgtc, + GL_ARB_texture_rg, + GL_ARB_vertex_array_object, + GL_ARB_uniform_buffer_object, + GL_ARB_compatibility, + GL_ARB_copy_buffer, + GL_ARB_shader_texture_lod, + GL_ARB_depth_clamp, + GL_ARB_draw_elements_base_vertex, + GL_ARB_fragment_coord_conventions, + GL_ARB_provoking_vertex, + GL_ARB_seamless_cube_map, + GL_ARB_sync, + GL_ARB_texture_multisample, + GL_ARB_vertex_array_bgra, + GL_ARB_draw_buffers_blend, + GL_ARB_sample_shading, + GL_ARB_texture_cube_map_array, + GL_ARB_texture_gather, + GL_ARB_texture_query_lod, + GL_ARB_shading_language_include, + GL_ARB_texture_compression_bptc, + GL_ARB_blend_func_extended, + GL_ARB_explicit_attrib_location, + GL_ARB_occlusion_query2, + GL_ARB_sampler_objects, + GL_ARB_shader_bit_encoding, + GL_ARB_texture_rgb10_a2ui, + GL_ARB_texture_swizzle, + GL_ARB_timer_query, + GL_ARB_vertex_type_2_10_10_10_rev, + GL_ARB_draw_indirect, + GL_ARB_gpu_shader5, + GL_ARB_gpu_shader_fp64, + GL_ARB_shader_subroutine, + GL_ARB_tessellation_shader, + GL_ARB_texture_buffer_object_rgb32, + GL_ARB_transform_feedback2, + GL_ARB_transform_feedback3, + GL_ARB_ES2_compatibility, + GL_ARB_get_program_binary, + GL_ARB_separate_shader_objects, + GL_ARB_shader_precision, + GL_ARB_vertex_attrib_64bit, + GL_ARB_viewport_array, + + // GL 4.2 + GL_ARB_base_instance, + GL_ARB_shading_language_420pack, + GL_ARB_transform_feedback_instanced, + GL_ARB_compressed_texture_pixel_storage, + GL_ARB_conservative_depth, + GL_ARB_internalformat_query, + GL_ARB_map_buffer_alignment, + GL_ARB_shader_atomic_counters, + GL_ARB_shader_image_load_store, + GL_ARB_shading_language_packing, + GL_ARB_texture_storage, + + + // GL 4.3 + GL_ARB_arrays_of_arrays, + GL_ARB_fragment_layer_viewport, + GL_ARB_shader_image_size, + GL_ARB_ES3_compatibility, + GL_ARB_clear_buffer_object, + GL_ARB_compute_shader, + GL_ARB_copy_image, + GL_KHR_debug, + GL_ARB_explicit_uniform_location, + GL_ARB_framebuffer_no_attachments, + GL_ARB_internalformat_query2, + GL_ARB_invalidate_subdata, + GL_ARB_multi_draw_indirect, + GL_ARB_program_interface_query, + GL_ARB_robust_buffer_access_behavior, + GL_ARB_shader_storage_buffer_object, + GL_ARB_stencil_texturing, + GL_ARB_texture_buffer_range, + GL_ARB_texture_query_levels, + GL_ARB_texture_storage_multisample, + GL_ARB_texture_view, + GL_ARB_vertex_attrib_binding, + GL_NV_path_rendering, + GL_AMD_pinned_memory, + GL_AMD_stencil_operation_extended, + GL_AMD_vertex_shader_viewport_index, + GL_AMD_vertex_shader_layer, + GL_NV_bindless_texture, + GL_NV_shader_atomic_float, + GL_AMD_query_buffer_object, + + + // GL 4.4 + GL_ARB_buffer_storage, + GL_ARB_clear_texture, + GL_ARB_enhanced_layouts, + GL_ARB_multi_bind, + GL_ARB_query_buffer_object, + GL_ARB_texture_mirror_clamp_to_edge, + GL_ARB_texture_stencil8, + GL_ARB_vertex_type_10f_11f_11f_rev, + GL_ARB_bindless_texture, + GL_ARB_sparse_texture, + + // GL 4.5 + GL_ARB_clip_control, + GL_ARB_cull_distance, + GL_ARB_ES3_1_compatibility, + GL_ARB_conditional_render_inverted, + GL_KHR_context_flush_control, + GL_ARB_derivative_control, + GL_ARB_direct_state_access, + GL_ARB_get_texture_sub_image, + GL_KHR_robustness, + GL_KHR_blend_equation_advanced, + GL_KHR_blend_equation_advanced_coherent, + GL_KHR_robust_buffer_access_behavior, + GL_ARB_shader_texture_image_samples, + GL_ARB_texture_barrier, + + GL_ARB_cl_event, + GL_ARB_compute_variable_group_size, + GL_ARB_debug_output, + GL_ARB_robustness, + GL_ARB_shader_stencil_export, + GL_ATI_draw_buffers, + GL_ATI_element_array, + GL_ATI_envmap_bumpmap, + GL_ATI_fragment_shader, + GL_ATI_map_object_buffer, + GL_ATI_pn_triangles, + GL_ATI_separate_stencil, + GL_ATI_text_fragment_shader, + GL_ATI_texture_env_combine3, + GL_ATI_texture_float, + GL_ATI_texture_mirror_once, + GL_ATI_vertex_array_object, + GL_ATI_vertex_attrib_array_object, + GL_ATI_vertex_streams, + GL_ATI_meminfo, + GL_AMD_performance_monitor, + GL_AMD_texture_texture4, + GL_AMD_vertex_shader_tesselator, + GL_AMD_draw_buffers_blend, + GL_AMD_shader_stencil_export, + GL_AMD_seamless_cubemap_per_texture, + GL_AMD_conservative_depth, + GL_AMD_name_gen_delete, + GL_AMD_debug_output, + GL_AMD_transform_feedback3_lines_triangles, + GL_AMD_depth_clamp_separate, + GL_EXT_422_pixels, + GL_EXT_abgr, + GL_EXT_bgra, + GL_EXT_blend_color, + GL_EXT_blend_func_separate, + GL_EXT_blend_logic_op, + GL_EXT_blend_minmax, + GL_EXT_blend_subtract, + GL_EXT_clip_volume_hint, + GL_EXT_cmyka, + GL_EXT_color_matrix, + GL_EXT_color_subtable, + GL_EXT_compiled_vertex_array, + GL_EXT_convolution, + GL_EXT_coordinate_frame, + GL_EXT_copy_texture, + GL_EXT_cull_vertex, + GL_EXT_draw_range_elements, + GL_EXT_fog_coord, + GL_EXT_framebuffer_object, + GL_EXT_histogram, + GL_EXT_index_array_formats, + GL_EXT_index_func, + GL_EXT_index_material, + GL_EXT_index_texture, + GL_EXT_light_texture, + GL_EXT_misc_attribute, + GL_EXT_multi_draw_arrays, + GL_EXT_multisample, + GL_EXT_packed_pixels, + GL_EXT_paletted_texture, + GL_EXT_pixel_transform, + GL_EXT_pixel_transform_color_table, + GL_EXT_point_parameters, + GL_EXT_polygon_offset, + GL_EXT_rescale_normal, + GL_EXT_secondary_color, + GL_EXT_separate_specular_color, + GL_EXT_shadow_funcs, + GL_EXT_shared_texture_palette, + GL_EXT_stencil_two_side, + GL_EXT_stencil_wrap, + GL_EXT_subtexture, + GL_EXT_texture, + GL_EXT_texture3D, + GL_EXT_texture_compression_s3tc, + GL_EXT_texture_cube_map, + GL_EXT_texture_edge_clamp, + GL_EXT_texture_env_add, + GL_EXT_texture_env_combine, + GL_EXT_texture_env_dot3, + GL_EXT_texture_filter_anisotropic, + GL_EXT_texture_lod_bias, + GL_EXT_texture_object, + GL_EXT_texture_perturb_normal, + GL_EXT_texture_rectangle, + GL_EXT_vertex_array, + GL_EXT_vertex_shader, + GL_EXT_vertex_weighting, + GL_EXT_depth_bounds_test, + GL_EXT_texture_mirror_clamp, + GL_EXT_blend_equation_separate, + GL_EXT_pixel_buffer_object, + GL_EXT_texture_compression_dxt1, + GL_EXT_stencil_clear_tag, + GL_EXT_packed_depth_stencil, + GL_EXT_texture_sRGB, + GL_EXT_framebuffer_blit, + GL_EXT_framebuffer_multisample, + GL_EXT_timer_query, + GL_EXT_gpu_program_parameters, + GL_EXT_bindable_uniform, + GL_EXT_draw_buffers2, + GL_EXT_draw_instanced, + GL_EXT_framebuffer_sRGB, + GL_EXT_geometry_shader4, + GL_EXT_gpu_shader4, + GL_EXT_packed_float, + GL_EXT_texture_array, + GL_EXT_texture_buffer_object, + GL_EXT_texture_compression_latc, + GL_EXT_texture_compression_rgtc, + GL_EXT_texture_integer, + GL_EXT_texture_shared_exponent, + GL_EXT_transform_feedback, + GL_EXT_direct_state_access, + GL_EXT_vertex_array_bgra, + GL_EXT_texture_swizzle, + GL_EXT_provoking_vertex, + GL_EXT_texture_snorm, + GL_EXT_separate_shader_objects, + GL_EXT_shader_image_load_store, + GL_EXT_vertex_attrib_64bit, + GL_EXT_texture_sRGB_decode, + GL_FfdMaskSGIX, + GL_HP_convolution_border_modes, + GL_HP_image_transform, + GL_HP_occlusion_test, + GL_HP_texture_lighting, + GL_IBM_cull_vertex, + GL_IBM_multimode_draw_arrays, + GL_IBM_rasterpos_clip, + GL_IBM_texture_mirrored_repeat, + GL_IBM_vertex_array_lists, + GL_INGR_blend_func_separate, + GL_INGR_color_clamp, + GL_INGR_interlace_read, + GL_INGR_palette_buffer, + GL_INTEL_parallel_arrays, + GL_INTEL_texture_scissor, + GL_MESA_resize_buffers, + GL_MESA_window_pos, + GL_NV_blend_square, + GL_NV_copy_depth_to_color, + GL_NV_depth_clamp, + GL_NV_evaluators, + GL_NV_fence, + GL_NV_float_buffer, + GL_NV_fog_distance, + GL_NV_fragment_program, + GL_NV_half_float, + GL_NV_light_max_exponent, + GL_NV_multisample_filter_hint, + GL_NV_occlusion_query, + GL_NV_packed_depth_stencil, + GL_NV_pixel_data_range, + GL_NV_point_sprite, + GL_NV_primitive_restart, + GL_NV_register_combiners, + GL_NV_register_combiners2, + GL_NV_texgen_emboss, + GL_NV_texgen_reflection, + GL_NV_texture_compression_vtc, + GL_NV_texture_env_combine4, + GL_NV_texture_expand_normal, + GL_NV_texture_rectangle, + GL_NV_texture_shader, + GL_NV_texture_shader2, + GL_NV_texture_shader3, + GL_NV_vertex_array_range, + GL_NV_vertex_array_range2, + GL_NV_vertex_program, + GL_NV_vertex_program1_1, + GL_NV_vertex_program2, + GL_NV_fragment_program_option, + GL_NV_fragment_program2, + GL_NV_vertex_program2_option, + GL_NV_vertex_program3, + GL_NV_depth_buffer_float, + GL_NV_fragment_program4, + GL_NV_framebuffer_multisample_coverage, + GL_NV_geometry_program4, + GL_NV_gpu_program4, + GL_NV_parameter_buffer_object, + GL_NV_transform_feedback, + GL_NV_vertex_program4, + GL_NV_conditional_render, + GL_NV_present_video, + GL_NV_explicit_multisample, + GL_NV_transform_feedback2, + GL_NV_video_capture, + GL_NV_copy_image, + GL_NV_parameter_buffer_object2, + GL_NV_shader_buffer_load, + GL_NV_vertex_buffer_unified_memory, + GL_NV_gpu_program5, + GL_NV_gpu_shader5, + GL_NV_shader_buffer_store, + GL_NV_tessellation_program5, + GL_NV_vertex_attrib_integer_64bit, + GL_NV_multisample_coverage, + GL_NV_vdpau_interop, + GL_NV_texture_barrier, + GL_OML_interlace, + GL_OML_resample, + GL_OML_subsample, + GL_PGI_misc_hints, + GL_PGI_vertex_hints, + GL_REND_screen_coordinates, + GL_S3_s3tc, + GL_SGIS_detail_texture, + GL_SGIS_fog_function, + GL_SGIS_generate_mipmap, + GL_SGIS_multisample, + GL_SGIS_pixel_texture, + GL_SGIS_point_line_texgen, + GL_SGIS_point_parameters, + GL_SGIS_sharpen_texture, + GL_SGIS_texture4D, + GL_SGIS_texture_border_clamp, + GL_SGIS_texture_color_mask, + GL_SGIS_texture_edge_clamp, + GL_SGIS_texture_filter4, + GL_SGIS_texture_lod, + GL_SGIS_texture_select, + GL_SGIX_async, + GL_SGIX_async_histogram, + GL_SGIX_async_pixel, + GL_SGIX_blend_alpha_minmax, + GL_SGIX_calligraphic_fragment, + GL_SGIX_clipmap, + GL_SGIX_convolution_accuracy, + GL_SGIX_depth_pass_instrument, + GL_SGIX_depth_texture, + GL_SGIX_flush_raster, + GL_SGIX_fog_offset, + GL_SGIX_fog_scale, + GL_SGIX_fragment_lighting, + GL_SGIX_framezoom, + GL_SGIX_igloo_interface, + GL_SGIX_impact_pixel_texture, + GL_SGIX_instruments, + GL_SGIX_interlace, + GL_SGIX_ir_instrument1, + GL_SGIX_list_priority, + GL_SGIX_pixel_texture, + GL_SGIX_pixel_tiles, + GL_SGIX_polynomial_ffd, + GL_SGIX_reference_plane, + GL_SGIX_resample, + GL_SGIX_scalebias_hint, + GL_SGIX_shadow, + GL_SGIX_shadow_ambient, + GL_SGIX_sprite, + GL_SGIX_subsample, + GL_SGIX_tag_sample_buffer, + GL_SGIX_texture_add_env, + GL_SGIX_texture_coordinate_clamp, + GL_SGIX_texture_lod_bias, + GL_SGIX_texture_multi_buffer, + GL_SGIX_texture_scale_bias, + GL_SGIX_texture_select, + GL_SGIX_vertex_preclip, + GL_SGIX_ycrcb, + GL_SGIX_ycrcb_subsample, + GL_SGIX_ycrcba, + GL_SGI_color_matrix, + GL_SGI_color_table, + GL_SGI_depth_pass_instrument, + GL_SGI_texture_color_table, + GL_SUNX_constant_data, + GL_SUN_convolution_border_modes, + GL_SUN_global_alpha, + GL_SUN_mesh_array, + GL_SUN_slice_accum, + GL_SUN_triangle_list, + GL_SUN_vertex, + + // WGL + GL_WIN_phong_shading, + GL_WIN_specular_fog, + WGL_3DFX_multisample, + WGL_ARB_buffer_region, + WGL_ARB_extensions_string, + WGL_ARB_make_current_read, + WGL_ARB_multisample, + WGL_ARB_pbuffer, + WGL_ARB_pixel_format, + WGL_ARB_pixel_format_float, + WGL_ARB_render_texture, + WGL_ARB_create_context, + WGL_ARB_create_context_profile, + WGL_ARB_framebuffer_sRGB, + WGL_ARB_create_context_robustness, + WGL_ATI_pixel_format_float, + WGL_AMD_gpu_association, + WGL_EXT_depth_float, + WGL_EXT_display_color_table, + WGL_EXT_extensions_string, + WGL_EXT_make_current_read, + WGL_EXT_multisample, + WGL_EXT_pbuffer, + WGL_EXT_pixel_format, + WGL_EXT_swap_control, + WGL_EXT_create_context_es2_profile, + WGL_I3D_digital_video_control, + WGL_I3D_gamma, + WGL_I3D_genlock, + WGL_I3D_image_buffer, + WGL_I3D_swap_frame_lock, + WGL_I3D_swap_frame_usage, + WGL_NV_float_buffer, + WGL_NV_render_depth_texture, + WGL_NV_render_texture_rectangle, + WGL_NV_vertex_array_range, + WGL_NV_present_video, + WGL_NV_video_output, + WGL_NV_swap_group, + WGL_NV_gpu_affinity, + WGL_NV_video_capture, + WGL_NV_copy_image, + WGL_NV_multisample_coverage, + WGL_NV_DX_interop, + WGL_OML_sync_control, + WGL_3DL_stereo_control, + WGL_ARB_context_flush_control, + WIN_draw_range_elements, + WIN_swap_hint, + + // GLX + GLX_VERSION_1_3, + GLX_VERSION_1_4, + GLX_ARB_multisample, + GLX_ARB_fbconfig_float, + GLX_ARB_get_proc_address, + GLX_ARB_create_context, + GLX_ARB_create_context_profile, + GLX_ARB_vertex_buffer_object, + GLX_ARB_framebuffer_sRGB, + GLX_ARB_create_context_robustness, + GLX_EXT_visual_info, + GLX_EXT_visual_rating, + GLX_EXT_import_context, + GLX_EXT_fbconfig_packed_float, + GLX_EXT_framebuffer_sRGB, + GLX_EXT_texture_from_pixmap, + GLX_EXT_swap_control, + GLX_ARB_context_flush_control, + GLX_EXT_create_context_es2_profile : Boolean; + +const + // GL_VERSION_1_1 + { AttribMask } + GL_DEPTH_BUFFER_BIT = $00000100; + GL_STENCIL_BUFFER_BIT = $00000400; + GL_COLOR_BUFFER_BIT = $00004000; + { Boolean } + GL_TRUE: ByteBool = True; + GL_FALSE: ByteBool = False; + { BeginMode } + GL_POINTS = $0000; + GL_LINES = $0001; + GL_LINE_LOOP = $0002; + GL_LINE_STRIP = $0003; + GL_TRIANGLES = $0004; + GL_TRIANGLE_STRIP = $0005; + GL_TRIANGLE_FAN = $0006; + { AlphaFunction } + GL_NEVER = $0200; + GL_LESS = $0201; + GL_EQUAL = $0202; + GL_LEQUAL = $0203; + GL_GREATER = $0204; + GL_NOTEQUAL = $0205; + GL_GEQUAL = $0206; + GL_ALWAYS = $0207; + { BlendingFactorDest } + GL_ZERO = 0; + GL_ONE = 1; + GL_SRC_COLOR = $0300; + GL_ONE_MINUS_SRC_COLOR = $0301; + GL_SRC_ALPHA = $0302; + GL_ONE_MINUS_SRC_ALPHA = $0303; + GL_DST_ALPHA = $0304; + GL_ONE_MINUS_DST_ALPHA = $0305; + { BlendingFactorSrc } + GL_DST_COLOR = $0306; + GL_ONE_MINUS_DST_COLOR = $0307; + GL_SRC_ALPHA_SATURATE = $0308; + { DrawBufferMode } + GL_NONE = 0; + GL_FRONT_LEFT = $0400; + GL_FRONT_RIGHT = $0401; + GL_BACK_LEFT = $0402; + GL_BACK_RIGHT = $0403; + GL_FRONT = $0404; + GL_BACK = $0405; + GL_LEFT = $0406; + GL_RIGHT = $0407; + GL_FRONT_AND_BACK = $0408; + { ErrorCode } + GL_NO_ERROR = 0; + GL_INVALID_ENUM = $0500; + GL_INVALID_VALUE = $0501; + GL_INVALID_OPERATION = $0502; + GL_OUT_OF_MEMORY = $0505; + { FrontFaceDirection } + GL_CW = $0900; + GL_CCW = $0901; + { GetPName } + GL_POINT_SIZE = $0B11; + GL_POINT_SIZE_RANGE = $0B12; + GL_POINT_SIZE_GRANULARITY = $0B13; + GL_LINE_SMOOTH = $0B20; + GL_LINE_WIDTH = $0B21; + GL_LINE_WIDTH_RANGE = $0B22; + GL_LINE_WIDTH_GRANULARITY = $0B23; + GL_POLYGON_SMOOTH = $0B41; + GL_CULL_FACE = $0B44; + GL_CULL_FACE_MODE = $0B45; + GL_FRONT_FACE = $0B46; + GL_DEPTH_RANGE = $0B70; + GL_DEPTH_TEST = $0B71; + GL_DEPTH_WRITEMASK = $0B72; + GL_DEPTH_CLEAR_VALUE = $0B73; + GL_DEPTH_FUNC = $0B74; + GL_STENCIL_TEST = $0B90; + GL_STENCIL_CLEAR_VALUE = $0B91; + GL_STENCIL_FUNC = $0B92; + GL_STENCIL_VALUE_MASK = $0B93; + GL_STENCIL_FAIL = $0B94; + GL_STENCIL_PASS_DEPTH_FAIL = $0B95; + GL_STENCIL_PASS_DEPTH_PASS = $0B96; + GL_STENCIL_REF = $0B97; + GL_STENCIL_WRITEMASK = $0B98; + GL_VIEWPORT = $0BA2; + GL_DITHER = $0BD0; + GL_BLEND_DST = $0BE0; + GL_BLEND_SRC = $0BE1; + GL_BLEND = $0BE2; + GL_LOGIC_OP_MODE = $0BF0; + GL_COLOR_LOGIC_OP = $0BF2; + GL_DRAW_BUFFER = $0C01; + GL_READ_BUFFER = $0C02; + GL_SCISSOR_BOX = $0C10; + GL_SCISSOR_TEST = $0C11; + GL_COLOR_CLEAR_VALUE = $0C22; + GL_COLOR_WRITEMASK = $0C23; + GL_DOUBLEBUFFER = $0C32; + GL_STEREO = $0C33; + GL_LINE_SMOOTH_HINT = $0C52; + GL_POLYGON_SMOOTH_HINT = $0C53; + GL_UNPACK_SWAP_BYTES = $0CF0; + GL_UNPACK_LSB_FIRST = $0CF1; + GL_UNPACK_ROW_LENGTH = $0CF2; + GL_UNPACK_SKIP_ROWS = $0CF3; + GL_UNPACK_SKIP_PIXELS = $0CF4; + GL_UNPACK_ALIGNMENT = $0CF5; + GL_PACK_SWAP_BYTES = $0D00; + GL_PACK_LSB_FIRST = $0D01; + GL_PACK_ROW_LENGTH = $0D02; + GL_PACK_SKIP_ROWS = $0D03; + GL_PACK_SKIP_PIXELS = $0D04; + GL_PACK_ALIGNMENT = $0D05; + GL_MAX_TEXTURE_SIZE = $0D33; + GL_MAX_VIEWPORT_DIMS = $0D3A; + GL_SUBPIXEL_BITS = $0D50; + GL_TEXTURE_1D = $0DE0; + GL_TEXTURE_2D = $0DE1; + GL_POLYGON_OFFSET_UNITS = $2A00; + GL_POLYGON_OFFSET_POINT = $2A01; + GL_POLYGON_OFFSET_LINE = $2A02; + GL_POLYGON_OFFSET_FILL = $8037; + GL_POLYGON_OFFSET_FACTOR = $8038; + GL_TEXTURE_BINDING_1D = $8068; + GL_TEXTURE_BINDING_2D = $8069; + { GetTextureParameter } + GL_TEXTURE_WIDTH = $1000; + GL_TEXTURE_HEIGHT = $1001; + GL_TEXTURE_INTERNAL_FORMAT = $1003; + GL_TEXTURE_BORDER_COLOR = $1004; + GL_TEXTURE_BORDER = $1005; + GL_TEXTURE_RED_SIZE = $805C; + GL_TEXTURE_GREEN_SIZE = $805D; + GL_TEXTURE_BLUE_SIZE = $805E; + GL_TEXTURE_ALPHA_SIZE = $805F; + { HintMode } + GL_DONT_CARE = $1100; + GL_FASTEST = $1101; + GL_NICEST = $1102; + { DataType } + GL_BYTE = $1400; + GL_UNSIGNED_BYTE = $1401; + GL_SHORT = $1402; + GL_UNSIGNED_SHORT = $1403; + GL_INT = $1404; + GL_UNSIGNED_INT = $1405; + GL_FLOAT = $1406; + GL_DOUBLE = $140A; + { LogicOp } + GL_CLEAR = $1500; + GL_AND = $1501; + GL_AND_REVERSE = $1502; + GL_COPY = $1503; + GL_AND_INVERTED = $1504; + GL_NOOP = $1505; + GL_XOR = $1506; + GL_OR = $1507; + GL_NOR = $1508; + GL_EQUIV = $1509; + GL_INVERT = $150A; + GL_OR_REVERSE = $150B; + GL_COPY_INVERTED = $150C; + GL_OR_INVERTED = $150D; + GL_NAND = $150E; + GL_SET = $150F; + { MatrixMode (for gl3.h, FBO attachment type) } + GL_TEXTURE = $1702; + { PixelCopyType } + GL_COLOR = $1800; + GL_DEPTH = $1801; + GL_STENCIL = $1802; + { PixelFormat } + GL_STENCIL_INDEX = $1901; + GL_DEPTH_COMPONENT = $1902; + GL_RED = $1903; + GL_GREEN = $1904; + GL_BLUE = $1905; + GL_ALPHA = $1906; + GL_RGB = $1907; + GL_RGBA = $1908; + { PolygonMode } + GL_POINT = $1B00; + GL_LINE = $1B01; + GL_FILL = $1B02; + { StencilOp } + GL_KEEP = $1E00; + GL_REPLACE = $1E01; + GL_INCR = $1E02; + GL_DECR = $1E03; + { StringName } + GL_VENDOR = $1F00; + GL_RENDERER = $1F01; + GL_VERSION = $1F02; + GL_EXTENSIONS = $1F03; + { TextureMagFilter } + GL_NEAREST = $2600; + GL_LINEAR = $2601; + { TextureMinFilter } + GL_NEAREST_MIPMAP_NEAREST = $2700; + GL_LINEAR_MIPMAP_NEAREST = $2701; + GL_NEAREST_MIPMAP_LINEAR = $2702; + GL_LINEAR_MIPMAP_LINEAR = $2703; + { TextureParameterName } + GL_TEXTURE_MAG_FILTER = $2800; + GL_TEXTURE_MIN_FILTER = $2801; + GL_TEXTURE_WRAP_S = $2802; + GL_TEXTURE_WRAP_T = $2803; + { TextureTarget } + GL_PROXY_TEXTURE_1D = $8063; + GL_PROXY_TEXTURE_2D = $8064; + { TextureWrapMode } + GL_REPEAT = $2901; + { PixelInternalFormat } + GL_R3_G3_B2 = $2A10; + GL_RGB4 = $804F; + GL_RGB5 = $8050; + GL_RGB8 = $8051; + GL_RGB10 = $8052; + GL_RGB12 = $8053; + GL_RGB16 = $8054; + GL_RGBA2 = $8055; + GL_RGBA4 = $8056; + GL_RGB5_A1 = $8057; + GL_RGBA8 = $8058; + GL_RGB10_A2 = $8059; + GL_RGBA12 = $805A; + GL_RGBA16 = $805B; + GL_ACCUM = $0100; + GL_LOAD = $0101; + GL_RETURN = $0102; + GL_MULT = $0103; + GL_ADD = $0104; + GL_CURRENT_BIT = $00000001; + GL_POINT_BIT = $00000002; + GL_LINE_BIT = $00000004; + GL_POLYGON_BIT = $00000008; + GL_POLYGON_STIPPLE_BIT = $00000010; + GL_PIXEL_MODE_BIT = $00000020; + GL_LIGHTING_BIT = $00000040; + GL_FOG_BIT = $00000080; + GL_ACCUM_BUFFER_BIT = $00000200; + GL_VIEWPORT_BIT = $00000800; + GL_TRANSFORM_BIT = $00001000; + GL_ENABLE_BIT = $00002000; + GL_HINT_BIT = $00008000; + GL_EVAL_BIT = $00010000; + GL_LIST_BIT = $00020000; + GL_TEXTURE_BIT = $00040000; + GL_SCISSOR_BIT = $00080000; + GL_ALL_ATTRIB_BITS = $000FFFFF; + GL_QUADS = $0007; + GL_QUAD_STRIP = $0008; + GL_POLYGON = $0009; + GL_CLIP_PLANE0 = $3000; + GL_CLIP_PLANE1 = $3001; + GL_CLIP_PLANE2 = $3002; + GL_CLIP_PLANE3 = $3003; + GL_CLIP_PLANE4 = $3004; + GL_CLIP_PLANE5 = $3005; + GL_2_BYTES = $1407; + GL_3_BYTES = $1408; + GL_4_BYTES = $1409; + GL_AUX0 = $0409; + GL_AUX1 = $040A; + GL_AUX2 = $040B; + GL_AUX3 = $040C; + GL_STACK_OVERFLOW = $0503; + GL_STACK_UNDERFLOW = $0504; + GL_2D = $0600; + GL_3D = $0601; + GL_3D_COLOR = $0602; + GL_3D_COLOR_TEXTURE = $0603; + GL_4D_COLOR_TEXTURE = $0604; + GL_PASS_THROUGH_TOKEN = $0700; + GL_POINT_TOKEN = $0701; + GL_LINE_TOKEN = $0702; + GL_POLYGON_TOKEN = $0703; + GL_BITMAP_TOKEN = $0704; + GL_DRAW_PIXEL_TOKEN = $0705; + GL_COPY_PIXEL_TOKEN = $0706; + GL_LINE_RESET_TOKEN = $0707; + GL_EXP = $0800; + GL_EXP2 = $0801; + GL_COEFF = $0A00; + GL_ORDER = $0A01; + GL_DOMAIN = $0A02; + GL_CURRENT_COLOR = $0B00; + GL_CURRENT_INDEX = $0B01; + GL_CURRENT_NORMAL = $0B02; + GL_CURRENT_TEXTURE_COORDS = $0B03; + GL_CURRENT_RASTER_COLOR = $0B04; + GL_CURRENT_RASTER_INDEX = $0B05; + GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06; + GL_CURRENT_RASTER_POSITION = $0B07; + GL_CURRENT_RASTER_POSITION_VALID = $0B08; + GL_CURRENT_RASTER_DISTANCE = $0B09; + GL_POINT_SMOOTH = $0B10; + GL_LINE_STIPPLE = $0B24; + GL_LINE_STIPPLE_PATTERN = $0B25; + GL_LINE_STIPPLE_REPEAT = $0B26; + GL_LIST_MODE = $0B30; + GL_MAX_LIST_NESTING = $0B31; + GL_LIST_BASE = $0B32; + GL_LIST_INDEX = $0B33; + GL_POLYGON_MODE = $0B40; + GL_POLYGON_STIPPLE = $0B42; + GL_EDGE_FLAG = $0B43; + GL_LIGHTING = $0B50; + GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51; + GL_LIGHT_MODEL_TWO_SIDE = $0B52; + GL_LIGHT_MODEL_AMBIENT = $0B53; + GL_SHADE_MODEL = $0B54; + GL_COLOR_MATERIAL_FACE = $0B55; + GL_COLOR_MATERIAL_PARAMETER = $0B56; + GL_COLOR_MATERIAL = $0B57; + GL_FOG = $0B60; + GL_FOG_INDEX = $0B61; + GL_FOG_DENSITY = $0B62; + GL_FOG_START = $0B63; + GL_FOG_END = $0B64; + GL_FOG_MODE = $0B65; + GL_FOG_COLOR = $0B66; + GL_ACCUM_CLEAR_VALUE = $0B80; + GL_MATRIX_MODE = $0BA0; + GL_NORMALIZE = $0BA1; + GL_MODELVIEW_STACK_DEPTH = $0BA3; + GL_PROJECTION_STACK_DEPTH = $0BA4; + GL_TEXTURE_STACK_DEPTH = $0BA5; + GL_MODELVIEW_MATRIX = $0BA6; + GL_PROJECTION_MATRIX = $0BA7; + GL_TEXTURE_MATRIX = $0BA8; + GL_ATTRIB_STACK_DEPTH = $0BB0; + GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1; + GL_ALPHA_TEST = $0BC0; + GL_ALPHA_TEST_FUNC = $0BC1; + GL_ALPHA_TEST_REF = $0BC2; + GL_INDEX_LOGIC_OP = $0BF1; + GL_AUX_BUFFERS = $0C00; + GL_INDEX_CLEAR_VALUE = $0C20; + GL_INDEX_WRITEMASK = $0C21; + GL_INDEX_MODE = $0C30; + GL_RGBA_MODE = $0C31; + GL_RENDER_MODE = $0C40; + GL_PERSPECTIVE_CORRECTION_HINT = $0C50; + GL_POINT_SMOOTH_HINT = $0C51; + GL_FOG_HINT = $0C54; + GL_TEXTURE_GEN_S = $0C60; + GL_TEXTURE_GEN_T = $0C61; + GL_TEXTURE_GEN_R = $0C62; + GL_TEXTURE_GEN_Q = $0C63; + GL_PIXEL_MAP_I_TO_I = $0C70; + GL_PIXEL_MAP_S_TO_S = $0C71; + GL_PIXEL_MAP_I_TO_R = $0C72; + GL_PIXEL_MAP_I_TO_G = $0C73; + GL_PIXEL_MAP_I_TO_B = $0C74; + GL_PIXEL_MAP_I_TO_A = $0C75; + GL_PIXEL_MAP_R_TO_R = $0C76; + GL_PIXEL_MAP_G_TO_G = $0C77; + GL_PIXEL_MAP_B_TO_B = $0C78; + GL_PIXEL_MAP_A_TO_A = $0C79; + GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0; + GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1; + GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2; + GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3; + GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4; + GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5; + GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6; + GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7; + GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8; + GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9; + GL_MAP_COLOR = $0D10; + GL_MAP_STENCIL = $0D11; + GL_INDEX_SHIFT = $0D12; + GL_INDEX_OFFSET = $0D13; + GL_RED_SCALE = $0D14; + GL_RED_BIAS = $0D15; + GL_ZOOM_X = $0D16; + GL_ZOOM_Y = $0D17; + GL_GREEN_SCALE = $0D18; + GL_GREEN_BIAS = $0D19; + GL_BLUE_SCALE = $0D1A; + GL_BLUE_BIAS = $0D1B; + GL_ALPHA_SCALE = $0D1C; + GL_ALPHA_BIAS = $0D1D; + GL_DEPTH_SCALE = $0D1E; + GL_DEPTH_BIAS = $0D1F; + GL_MAX_EVAL_ORDER = $0D30; + GL_MAX_LIGHTS = $0D31; + GL_MAX_CLIP_PLANES = $0D32; + GL_MAX_PIXEL_MAP_TABLE = $0D34; + GL_MAX_ATTRIB_STACK_DEPTH = $0D35; + GL_MAX_MODELVIEW_STACK_DEPTH = $0D36; + GL_MAX_NAME_STACK_DEPTH = $0D37; + GL_MAX_PROJECTION_STACK_DEPTH = $0D38; + GL_MAX_TEXTURE_STACK_DEPTH = $0D39; + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B; + GL_INDEX_BITS = $0D51; + GL_RED_BITS = $0D52; + GL_GREEN_BITS = $0D53; + GL_BLUE_BITS = $0D54; + GL_ALPHA_BITS = $0D55; + GL_DEPTH_BITS = $0D56; + GL_STENCIL_BITS = $0D57; + GL_ACCUM_RED_BITS = $0D58; + GL_ACCUM_GREEN_BITS = $0D59; + GL_ACCUM_BLUE_BITS = $0D5A; + GL_ACCUM_ALPHA_BITS = $0D5B; + GL_NAME_STACK_DEPTH = $0D70; + GL_AUTO_NORMAL = $0D80; + GL_MAP1_COLOR_4 = $0D90; + GL_MAP1_INDEX = $0D91; + GL_MAP1_NORMAL = $0D92; + GL_MAP1_TEXTURE_COORD_1 = $0D93; + GL_MAP1_TEXTURE_COORD_2 = $0D94; + GL_MAP1_TEXTURE_COORD_3 = $0D95; + GL_MAP1_TEXTURE_COORD_4 = $0D96; + GL_MAP1_VERTEX_3 = $0D97; + GL_MAP1_VERTEX_4 = $0D98; + GL_MAP2_COLOR_4 = $0DB0; + GL_MAP2_INDEX = $0DB1; + GL_MAP2_NORMAL = $0DB2; + GL_MAP2_TEXTURE_COORD_1 = $0DB3; + GL_MAP2_TEXTURE_COORD_2 = $0DB4; + GL_MAP2_TEXTURE_COORD_3 = $0DB5; + GL_MAP2_TEXTURE_COORD_4 = $0DB6; + GL_MAP2_VERTEX_3 = $0DB7; + GL_MAP2_VERTEX_4 = $0DB8; + GL_MAP1_GRID_DOMAIN = $0DD0; + GL_MAP1_GRID_SEGMENTS = $0DD1; + GL_MAP2_GRID_DOMAIN = $0DD2; + GL_MAP2_GRID_SEGMENTS = $0DD3; + GL_FEEDBACK_BUFFER_POINTER = $0DF0; + GL_FEEDBACK_BUFFER_SIZE = $0DF1; + GL_FEEDBACK_BUFFER_TYPE = $0DF2; + GL_SELECTION_BUFFER_POINTER = $0DF3; + GL_SELECTION_BUFFER_SIZE = $0DF4; + GL_LIGHT0 = $4000; + GL_LIGHT1 = $4001; + GL_LIGHT2 = $4002; + GL_LIGHT3 = $4003; + GL_LIGHT4 = $4004; + GL_LIGHT5 = $4005; + GL_LIGHT6 = $4006; + GL_LIGHT7 = $4007; + GL_AMBIENT = $1200; + GL_DIFFUSE = $1201; + GL_SPECULAR = $1202; + GL_POSITION = $1203; + GL_SPOT_DIRECTION = $1204; + GL_SPOT_EXPONENT = $1205; + GL_SPOT_CUTOFF = $1206; + GL_CONSTANT_ATTENUATION = $1207; + GL_LINEAR_ATTENUATION = $1208; + GL_QUADRATIC_ATTENUATION = $1209; + GL_COMPILE = $1300; + GL_COMPILE_AND_EXECUTE = $1301; + GL_EMISSION = $1600; + GL_SHININESS = $1601; + GL_AMBIENT_AND_DIFFUSE = $1602; + GL_COLOR_INDEXES = $1603; + GL_MODELVIEW = $1700; + GL_PROJECTION = $1701; + GL_COLOR_INDEX = $1900; + GL_LUMINANCE = $1909; + GL_LUMINANCE_ALPHA = $190A; + GL_BITMAP = $1A00; + GL_RENDER = $1C00; + GL_FEEDBACK = $1C01; + GL_SELECT = $1C02; + GL_FLAT = $1D00; + GL_SMOOTH = $1D01; + GL_S = $2000; + GL_T = $2001; + GL_R = $2002; + GL_Q = $2003; + GL_MODULATE = $2100; + GL_DECAL = $2101; + GL_TEXTURE_ENV_MODE = $2200; + GL_TEXTURE_ENV_COLOR = $2201; + GL_TEXTURE_ENV = $2300; + GL_EYE_LINEAR = $2400; + GL_OBJECT_LINEAR = $2401; + GL_SPHERE_MAP = $2402; + GL_TEXTURE_GEN_MODE = $2500; + GL_OBJECT_PLANE = $2501; + GL_EYE_PLANE = $2502; + GL_CLAMP = $2900; + GL_CLIENT_PIXEL_STORE_BIT = $00000001; + GL_CLIENT_VERTEX_ARRAY_BIT = $00000002; + GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF; + GL_ALPHA4 = $803B; + GL_ALPHA8 = $803C; + GL_ALPHA12 = $803D; + GL_ALPHA16 = $803E; + GL_LUMINANCE4 = $803F; + GL_LUMINANCE8 = $8040; + GL_LUMINANCE12 = $8041; + GL_LUMINANCE16 = $8042; + GL_LUMINANCE4_ALPHA4 = $8043; + GL_LUMINANCE6_ALPHA2 = $8044; + GL_LUMINANCE8_ALPHA8 = $8045; + GL_LUMINANCE12_ALPHA4 = $8046; + GL_LUMINANCE12_ALPHA12 = $8047; + GL_LUMINANCE16_ALPHA16 = $8048; + GL_INTENSITY = $8049; + GL_INTENSITY4 = $804A; + GL_INTENSITY8 = $804B; + GL_INTENSITY12 = $804C; + GL_INTENSITY16 = $804D; + GL_TEXTURE_LUMINANCE_SIZE = $8060; + GL_TEXTURE_INTENSITY_SIZE = $8061; + GL_TEXTURE_PRIORITY = $8066; + GL_TEXTURE_RESIDENT = $8067; + GL_VERTEX_ARRAY = $8074; + GL_NORMAL_ARRAY = $8075; + GL_COLOR_ARRAY = $8076; + GL_INDEX_ARRAY = $8077; + GL_TEXTURE_COORD_ARRAY = $8078; + GL_EDGE_FLAG_ARRAY = $8079; + GL_VERTEX_ARRAY_SIZE = $807A; + GL_VERTEX_ARRAY_TYPE = $807B; + GL_VERTEX_ARRAY_STRIDE = $807C; + GL_NORMAL_ARRAY_TYPE = $807E; + GL_NORMAL_ARRAY_STRIDE = $807F; + GL_COLOR_ARRAY_SIZE = $8081; + GL_COLOR_ARRAY_TYPE = $8082; + GL_COLOR_ARRAY_STRIDE = $8083; + GL_INDEX_ARRAY_TYPE = $8085; + GL_INDEX_ARRAY_STRIDE = $8086; + GL_TEXTURE_COORD_ARRAY_SIZE = $8088; + GL_TEXTURE_COORD_ARRAY_TYPE = $8089; + GL_TEXTURE_COORD_ARRAY_STRIDE = $808A; + GL_EDGE_FLAG_ARRAY_STRIDE = $808C; + GL_VERTEX_ARRAY_POINTER = $808E; + GL_NORMAL_ARRAY_POINTER = $808F; + GL_COLOR_ARRAY_POINTER = $8090; + GL_INDEX_ARRAY_POINTER = $8091; + GL_TEXTURE_COORD_ARRAY_POINTER = $8092; + GL_EDGE_FLAG_ARRAY_POINTER = $8093; + GL_V2F = $2A20; + GL_V3F = $2A21; + GL_C4UB_V2F = $2A22; + GL_C4UB_V3F = $2A23; + GL_C3F_V3F = $2A24; + GL_N3F_V3F = $2A25; + GL_C4F_N3F_V3F = $2A26; + GL_T2F_V3F = $2A27; + GL_T4F_V4F = $2A28; + GL_T2F_C4UB_V3F = $2A29; + GL_T2F_C3F_V3F = $2A2A; + GL_T2F_N3F_V3F = $2A2B; + GL_T2F_C4F_N3F_V3F = $2A2C; + GL_T4F_C4F_N3F_V4F = $2A2D; + GL_COLOR_TABLE_FORMAT_EXT = $80D8; + GL_COLOR_TABLE_WIDTH_EXT = $80D9; + GL_COLOR_TABLE_RED_SIZE_EXT = $80DA; + GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB; + GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF; + GL_LOGIC_OP = GL_INDEX_LOGIC_OP; + GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT; + + // GL_VERSION_1_2 + GL_UNSIGNED_BYTE_3_3_2 = $8032; + GL_UNSIGNED_SHORT_4_4_4_4 = $8033; + GL_UNSIGNED_SHORT_5_5_5_1 = $8034; + GL_UNSIGNED_INT_8_8_8_8 = $8035; + GL_UNSIGNED_INT_10_10_10_2 = $8036; + GL_TEXTURE_BINDING_3D = $806A; + GL_PACK_SKIP_IMAGES = $806B; + GL_PACK_IMAGE_HEIGHT = $806C; + GL_UNPACK_SKIP_IMAGES = $806D; + GL_UNPACK_IMAGE_HEIGHT = $806E; + GL_TEXTURE_3D = $806F; + GL_PROXY_TEXTURE_3D = $8070; + GL_TEXTURE_DEPTH = $8071; + GL_TEXTURE_WRAP_R = $8072; + GL_MAX_3D_TEXTURE_SIZE = $8073; + GL_UNSIGNED_BYTE_2_3_3_REV = $8362; + GL_UNSIGNED_SHORT_5_6_5 = $8363; + GL_UNSIGNED_SHORT_5_6_5_REV = $8364; + GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365; + GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366; + GL_UNSIGNED_INT_8_8_8_8_REV = $8367; + GL_UNSIGNED_INT_2_10_10_10_REV = $8368; + GL_BGR = $80E0; + GL_BGRA = $80E1; + GL_MAX_ELEMENTS_VERTICES = $80E8; + GL_MAX_ELEMENTS_INDICES = $80E9; + GL_CLAMP_TO_EDGE = $812F; + GL_TEXTURE_MIN_LOD = $813A; + GL_TEXTURE_MAX_LOD = $813B; + GL_TEXTURE_BASE_LEVEL = $813C; + GL_TEXTURE_MAX_LEVEL = $813D; + GL_SMOOTH_POINT_SIZE_RANGE = $0B12; + GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13; + GL_SMOOTH_LINE_WIDTH_RANGE = $0B22; + GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23; + GL_ALIASED_LINE_WIDTH_RANGE = $846E; + GL_RESCALE_NORMAL = $803A; + GL_LIGHT_MODEL_COLOR_CONTROL = $81F8; + GL_SINGLE_COLOR = $81F9; + GL_SEPARATE_SPECULAR_COLOR = $81FA; + GL_ALIASED_POINT_SIZE_RANGE = $846D; + // GL_VERSION_1_3 + GL_TEXTURE0 = $84C0; + GL_TEXTURE1 = $84C1; + GL_TEXTURE2 = $84C2; + GL_TEXTURE3 = $84C3; + GL_TEXTURE4 = $84C4; + GL_TEXTURE5 = $84C5; + GL_TEXTURE6 = $84C6; + GL_TEXTURE7 = $84C7; + GL_TEXTURE8 = $84C8; + GL_TEXTURE9 = $84C9; + GL_TEXTURE10 = $84CA; + GL_TEXTURE11 = $84CB; + GL_TEXTURE12 = $84CC; + GL_TEXTURE13 = $84CD; + GL_TEXTURE14 = $84CE; + GL_TEXTURE15 = $84CF; + GL_TEXTURE16 = $84D0; + GL_TEXTURE17 = $84D1; + GL_TEXTURE18 = $84D2; + GL_TEXTURE19 = $84D3; + GL_TEXTURE20 = $84D4; + GL_TEXTURE21 = $84D5; + GL_TEXTURE22 = $84D6; + GL_TEXTURE23 = $84D7; + GL_TEXTURE24 = $84D8; + GL_TEXTURE25 = $84D9; + GL_TEXTURE26 = $84DA; + GL_TEXTURE27 = $84DB; + GL_TEXTURE28 = $84DC; + GL_TEXTURE29 = $84DD; + GL_TEXTURE30 = $84DE; + GL_TEXTURE31 = $84DF; + GL_ACTIVE_TEXTURE = $84E0; + GL_MULTISAMPLE = $809D; + GL_SAMPLE_ALPHA_TO_COVERAGE = $809E; + GL_SAMPLE_ALPHA_TO_ONE = $809F; + GL_SAMPLE_COVERAGE = $80A0; + GL_SAMPLE_BUFFERS = $80A8; + GL_SAMPLES = $80A9; + GL_SAMPLE_COVERAGE_VALUE = $80AA; + GL_SAMPLE_COVERAGE_INVERT = $80AB; + GL_TEXTURE_CUBE_MAP = $8513; + GL_TEXTURE_BINDING_CUBE_MAP = $8514; + GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A; + GL_PROXY_TEXTURE_CUBE_MAP = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; + GL_COMPRESSED_RGB = $84ED; + GL_COMPRESSED_RGBA = $84EE; + GL_TEXTURE_COMPRESSION_HINT = $84EF; + GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0; + GL_TEXTURE_COMPRESSED = $86A1; + GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2; + GL_COMPRESSED_TEXTURE_FORMATS = $86A3; + GL_CLAMP_TO_BORDER = $812D; + GL_CLIENT_ACTIVE_TEXTURE = $84E1; + GL_MAX_TEXTURE_UNITS = $84E2; + GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3; + GL_TRANSPOSE_PROJECTION_MATRIX = $84E4; + GL_TRANSPOSE_TEXTURE_MATRIX = $84E5; + GL_TRANSPOSE_COLOR_MATRIX = $84E6; + GL_MULTISAMPLE_BIT = $20000000; + GL_NORMAL_MAP = $8511; + GL_REFLECTION_MAP = $8512; + GL_COMPRESSED_ALPHA = $84E9; + GL_COMPRESSED_LUMINANCE = $84EA; + GL_COMPRESSED_LUMINANCE_ALPHA = $84EB; + GL_COMPRESSED_INTENSITY = $84EC; + GL_COMBINE = $8570; + GL_COMBINE_RGB = $8571; + GL_COMBINE_ALPHA = $8572; + GL_SOURCE0_RGB = $8580; + GL_SOURCE1_RGB = $8581; + GL_SOURCE2_RGB = $8582; + GL_SOURCE0_ALPHA = $8588; + GL_SOURCE1_ALPHA = $8589; + GL_SOURCE2_ALPHA = $858A; + GL_OPERAND0_RGB = $8590; + GL_OPERAND1_RGB = $8591; + GL_OPERAND2_RGB = $8592; + GL_OPERAND0_ALPHA = $8598; + GL_OPERAND1_ALPHA = $8599; + GL_OPERAND2_ALPHA = $859A; + GL_RGB_SCALE = $8573; + GL_ADD_SIGNED = $8574; + GL_INTERPOLATE = $8575; + GL_SUBTRACT = $84E7; + GL_CONSTANT = $8576; + GL_PRIMARY_COLOR = $8577; + GL_PREVIOUS = $8578; + GL_DOT3_RGB = $86AE; + GL_DOT3_RGBA = $86AF; + // GL_VERSION_1_4 + GL_BLEND_DST_RGB = $80C8; + GL_BLEND_SRC_RGB = $80C9; + GL_BLEND_DST_ALPHA = $80CA; + GL_BLEND_SRC_ALPHA = $80CB; + GL_POINT_FADE_THRESHOLD_SIZE = $8128; + GL_DEPTH_COMPONENT16 = $81A5; + GL_DEPTH_COMPONENT24 = $81A6; + GL_DEPTH_COMPONENT32 = $81A7; + GL_MIRRORED_REPEAT = $8370; + GL_MAX_TEXTURE_LOD_BIAS = $84FD; + GL_TEXTURE_LOD_BIAS = $8501; + GL_INCR_WRAP = $8507; + GL_DECR_WRAP = $8508; + GL_TEXTURE_DEPTH_SIZE = $884A; + GL_TEXTURE_COMPARE_MODE = $884C; + GL_TEXTURE_COMPARE_FUNC = $884D; + GL_POINT_SIZE_MIN = $8126; + GL_POINT_SIZE_MAX = $8127; + GL_POINT_DISTANCE_ATTENUATION = $8129; + GL_GENERATE_MIPMAP = $8191; + GL_GENERATE_MIPMAP_HINT = $8192; + GL_FOG_COORDINATE_SOURCE = $8450; + GL_FOG_COORDINATE = $8451; + GL_FRAGMENT_DEPTH = $8452; + GL_CURRENT_FOG_COORDINATE = $8453; + GL_FOG_COORDINATE_ARRAY_TYPE = $8454; + GL_FOG_COORDINATE_ARRAY_STRIDE = $8455; + GL_FOG_COORDINATE_ARRAY_POINTER = $8456; + GL_FOG_COORDINATE_ARRAY = $8457; + GL_COLOR_SUM = $8458; + GL_CURRENT_SECONDARY_COLOR = $8459; + GL_SECONDARY_COLOR_ARRAY_SIZE = $845A; + GL_SECONDARY_COLOR_ARRAY_TYPE = $845B; + GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C; + GL_SECONDARY_COLOR_ARRAY_POINTER = $845D; + GL_SECONDARY_COLOR_ARRAY = $845E; + GL_TEXTURE_FILTER_CONTROL = $8500; + GL_DEPTH_TEXTURE_MODE = $884B; + GL_COMPARE_R_TO_TEXTURE = $884E; + // GL_VERSION_1_5 + // GL_VERSION_2_0 + GL_BLEND_EQUATION_RGB = $8009; + GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622; + GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623; + GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624; + GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625; + GL_CURRENT_VERTEX_ATTRIB = $8626; + GL_VERTEX_PROGRAM_POINT_SIZE = $8642; + GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645; + GL_STENCIL_BACK_FUNC = $8800; + GL_STENCIL_BACK_FAIL = $8801; + GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802; + GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803; + GL_MAX_DRAW_BUFFERS = $8824; + GL_DRAW_BUFFER0 = $8825; + GL_DRAW_BUFFER1 = $8826; + GL_DRAW_BUFFER2 = $8827; + GL_DRAW_BUFFER3 = $8828; + GL_DRAW_BUFFER4 = $8829; + GL_DRAW_BUFFER5 = $882A; + GL_DRAW_BUFFER6 = $882B; + GL_DRAW_BUFFER7 = $882C; + GL_DRAW_BUFFER8 = $882D; + GL_DRAW_BUFFER9 = $882E; + GL_DRAW_BUFFER10 = $882F; + GL_DRAW_BUFFER11 = $8830; + GL_DRAW_BUFFER12 = $8831; + GL_DRAW_BUFFER13 = $8832; + GL_DRAW_BUFFER14 = $8833; + GL_DRAW_BUFFER15 = $8834; + GL_BLEND_EQUATION_ALPHA = $883D; + GL_MAX_VERTEX_ATTRIBS = $8869; + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A; + GL_MAX_TEXTURE_IMAGE_UNITS = $8872; + GL_FRAGMENT_SHADER = $8B30; + GL_VERTEX_SHADER = $8B31; + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49; + GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A; + GL_MAX_VARYING_FLOATS = $8B4B; + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C; + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D; + GL_SHADER_TYPE = $8B4F; + GL_FLOAT_VEC2 = $8B50; + GL_FLOAT_VEC3 = $8B51; + GL_FLOAT_VEC4 = $8B52; + GL_INT_VEC2 = $8B53; + GL_INT_VEC3 = $8B54; + GL_INT_VEC4 = $8B55; + GL_BOOL = $8B56; + GL_BOOL_VEC2 = $8B57; + GL_BOOL_VEC3 = $8B58; + GL_BOOL_VEC4 = $8B59; + GL_FLOAT_MAT2 = $8B5A; + GL_FLOAT_MAT3 = $8B5B; + GL_FLOAT_MAT4 = $8B5C; + GL_SAMPLER_1D = $8B5D; + GL_SAMPLER_2D = $8B5E; + GL_SAMPLER_3D = $8B5F; + GL_SAMPLER_CUBE = $8B60; + GL_SAMPLER_1D_SHADOW = $8B61; + GL_SAMPLER_2D_SHADOW = $8B62; + GL_DELETE_STATUS = $8B80; + GL_COMPILE_STATUS = $8B81; + GL_LINK_STATUS = $8B82; + GL_VALIDATE_STATUS = $8B83; + GL_INFO_LOG_LENGTH = $8B84; + GL_ATTACHED_SHADERS = $8B85; + GL_ACTIVE_UNIFORMS = $8B86; + GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87; + GL_SHADER_SOURCE_LENGTH = $8B88; + GL_ACTIVE_ATTRIBUTES = $8B89; + GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A; + GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B; + GL_SHADING_LANGUAGE_VERSION = $8B8C; + GL_CURRENT_PROGRAM = $8B8D; + GL_POINT_SPRITE_COORD_ORIGIN = $8CA0; + GL_LOWER_LEFT = $8CA1; + GL_UPPER_LEFT = $8CA2; + GL_STENCIL_BACK_REF = $8CA3; + GL_STENCIL_BACK_VALUE_MASK = $8CA4; + GL_STENCIL_BACK_WRITEMASK = $8CA5; + GL_VERTEX_PROGRAM_TWO_SIDE = $8643; + GL_POINT_SPRITE = $8861; + GL_COORD_REPLACE = $8862; + GL_MAX_TEXTURE_COORDS = $8871; + // GL_VERSION_2_1 + GL_PIXEL_PACK_BUFFER = $88EB; + GL_PIXEL_UNPACK_BUFFER = $88EC; + GL_PIXEL_PACK_BUFFER_BINDING = $88ED; + GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF; + GL_FLOAT_MAT2x3 = $8B65; + GL_FLOAT_MAT2x4 = $8B66; + GL_FLOAT_MAT3x2 = $8B67; + GL_FLOAT_MAT3x4 = $8B68; + GL_FLOAT_MAT4x2 = $8B69; + GL_FLOAT_MAT4x3 = $8B6A; + GL_SRGB = $8C40; + GL_SRGB8 = $8C41; + GL_SRGB_ALPHA = $8C42; + GL_SRGB8_ALPHA8 = $8C43; + GL_COMPRESSED_SRGB = $8C48; + GL_COMPRESSED_SRGB_ALPHA = $8C49; + GL_CURRENT_RASTER_SECONDARY_COLOR = $845F; + GL_SLUMINANCE_ALPHA = $8C44; + GL_SLUMINANCE8_ALPHA8 = $8C45; + GL_SLUMINANCE = $8C46; + GL_SLUMINANCE8 = $8C47; + GL_COMPRESSED_SLUMINANCE = $8C4A; + GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B; + // GL_VERSION_3_0 + GL_COMPARE_REF_TO_TEXTURE = $884E; + GL_CLIP_DISTANCE0 = $3000; + GL_CLIP_DISTANCE1 = $3001; + GL_CLIP_DISTANCE2 = $3002; + GL_CLIP_DISTANCE3 = $3003; + GL_CLIP_DISTANCE4 = $3004; + GL_CLIP_DISTANCE5 = $3005; + GL_CLIP_DISTANCE6 = $3006; + GL_CLIP_DISTANCE7 = $3007; + GL_MAX_CLIP_DISTANCES = $0D32; + GL_MAJOR_VERSION = $821B; + GL_MINOR_VERSION = $821C; + GL_NUM_EXTENSIONS = $821D; + GL_CONTEXT_FLAGS = $821E; + GL_DEPTH_BUFFER = $8223; + GL_STENCIL_BUFFER = $8224; + GL_COMPRESSED_RED = $8225; + GL_COMPRESSED_RG = $8226; + GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001; + GL_RGBA32F = $8814; + GL_RGB32F = $8815; + GL_RGBA16F = $881A; + GL_RGB16F = $881B; + GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD; + GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF; + GL_MIN_PROGRAM_TEXEL_OFFSET = $8904; + GL_MAX_PROGRAM_TEXEL_OFFSET = $8905; + GL_CLAMP_READ_COLOR = $891C; + GL_FIXED_ONLY = $891D; + GL_MAX_VARYING_COMPONENTS = $8B4B; + GL_TEXTURE_1D_ARRAY = $8C18; + GL_PROXY_TEXTURE_1D_ARRAY = $8C19; + GL_TEXTURE_2D_ARRAY = $8C1A; + GL_PROXY_TEXTURE_2D_ARRAY = $8C1B; + GL_TEXTURE_BINDING_1D_ARRAY = $8C1C; + GL_TEXTURE_BINDING_2D_ARRAY = $8C1D; + GL_R11F_G11F_B10F = $8C3A; + GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B; + GL_RGB9_E5 = $8C3D; + GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E; + GL_TEXTURE_SHARED_SIZE = $8C3F; + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76; + GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80; + GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83; + GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84; + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85; + GL_PRIMITIVES_GENERATED = $8C87; + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88; + GL_RASTERIZER_DISCARD = $8C89; + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B; + GL_INTERLEAVED_ATTRIBS = $8C8C; + GL_SEPARATE_ATTRIBS = $8C8D; + GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E; + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F; + GL_RGBA32UI = $8D70; + GL_RGB32UI = $8D71; + GL_RGBA16UI = $8D76; + GL_RGB16UI = $8D77; + GL_RGBA8UI = $8D7C; + GL_RGB8UI = $8D7D; + GL_RGBA32I = $8D82; + GL_RGB32I = $8D83; + GL_RGBA16I = $8D88; + GL_RGB16I = $8D89; + GL_RGBA8I = $8D8E; + GL_RGB8I = $8D8F; + GL_RED_INTEGER = $8D94; + GL_GREEN_INTEGER = $8D95; + GL_BLUE_INTEGER = $8D96; + GL_RGB_INTEGER = $8D98; + GL_RGBA_INTEGER = $8D99; + GL_BGR_INTEGER = $8D9A; + GL_BGRA_INTEGER = $8D9B; + GL_SAMPLER_1D_ARRAY = $8DC0; + GL_SAMPLER_2D_ARRAY = $8DC1; + GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3; + GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4; + GL_SAMPLER_CUBE_SHADOW = $8DC5; + GL_UNSIGNED_INT_VEC2 = $8DC6; + GL_UNSIGNED_INT_VEC3 = $8DC7; + GL_UNSIGNED_INT_VEC4 = $8DC8; + GL_INT_SAMPLER_1D = $8DC9; + GL_INT_SAMPLER_2D = $8DCA; + GL_INT_SAMPLER_3D = $8DCB; + GL_INT_SAMPLER_CUBE = $8DCC; + GL_INT_SAMPLER_1D_ARRAY = $8DCE; + GL_INT_SAMPLER_2D_ARRAY = $8DCF; + GL_UNSIGNED_INT_SAMPLER_1D = $8DD1; + GL_UNSIGNED_INT_SAMPLER_2D = $8DD2; + GL_UNSIGNED_INT_SAMPLER_3D = $8DD3; + GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4; + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6; + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7; + GL_QUERY_WAIT = $8E13; + GL_QUERY_NO_WAIT = $8E14; + GL_QUERY_BY_REGION_WAIT = $8E15; + GL_QUERY_BY_REGION_NO_WAIT = $8E16; + GL_BUFFER_ACCESS_FLAGS = $911F; + GL_BUFFER_MAP_LENGTH = $9120; + GL_BUFFER_MAP_OFFSET = $9121; + GL_CLAMP_VERTEX_COLOR = $891A; + GL_CLAMP_FRAGMENT_COLOR = $891B; + GL_ALPHA_INTEGER = $8D97; + // GL_VERSION_3_1 + GL_SAMPLER_2D_RECT = $8B63; + GL_SAMPLER_2D_RECT_SHADOW = $8B64; + GL_SAMPLER_BUFFER = $8DC2; + GL_INT_SAMPLER_2D_RECT = $8DCD; + GL_INT_SAMPLER_BUFFER = $8DD0; + GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5; + GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8; + GL_TEXTURE_BUFFER = $8C2A; + GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B; + GL_TEXTURE_BINDING_BUFFER = $8C2C; + GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D; + GL_TEXTURE_BUFFER_FORMAT = $8C2E; + GL_TEXTURE_RECTANGLE = $84F5; + GL_TEXTURE_BINDING_RECTANGLE = $84F6; + GL_PROXY_TEXTURE_RECTANGLE = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8; + GL_RED_SNORM = $8F90; + GL_RG_SNORM = $8F91; + GL_RGB_SNORM = $8F92; + GL_RGBA_SNORM = $8F93; + GL_R8_SNORM = $8F94; + GL_RG8_SNORM = $8F95; + GL_RGB8_SNORM = $8F96; + GL_RGBA8_SNORM = $8F97; + GL_R16_SNORM = $8F98; + GL_RG16_SNORM = $8F99; + GL_RGB16_SNORM = $8F9A; + GL_RGBA16_SNORM = $8F9B; + GL_SIGNED_NORMALIZED = $8F9C; + GL_PRIMITIVE_RESTART = $8F9D; + GL_PRIMITIVE_RESTART_INDEX = $8F9E; + // GL_VERSION_3_2 + GL_CONTEXT_CORE_PROFILE_BIT = $00000001; + GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002; + GL_LINES_ADJACENCY = $000A; + GL_LINE_STRIP_ADJACENCY = $000B; + GL_TRIANGLES_ADJACENCY = $000C; + GL_TRIANGLE_STRIP_ADJACENCY = $000D; + GL_PROGRAM_POINT_SIZE = $8642; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8; + GL_GEOMETRY_SHADER = $8DD9; + GL_GEOMETRY_VERTICES_OUT = $8916; + GL_GEOMETRY_INPUT_TYPE = $8917; + GL_GEOMETRY_OUTPUT_TYPE = $8918; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1; + GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122; + GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123; + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124; + GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125; + GL_CONTEXT_PROFILE_MASK = $9126; + // GL_VERSION_3_3 + GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE; + // GL_VERSION_4_0 + GL_SAMPLE_SHADING = $8C36; + GL_MIN_SAMPLE_SHADING_VALUE = $8C37; + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F; + GL_TEXTURE_CUBE_MAP_ARRAY = $9009; + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A; + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B; + GL_SAMPLER_CUBE_MAP_ARRAY = $900C; + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D; + GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E; + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F; + // GL_VERSION_4_3 + GL_NUM_SHADING_LANGUAGE_VERSIONS = $82E9; + GL_VERTEX_ATTRIB_ARRAY_LONG = $874E; + // GL_3DFX_multisample + GL_MULTISAMPLE_3DFX = $86B2; + GL_SAMPLE_BUFFERS_3DFX = $86B3; + GL_SAMPLES_3DFX = $86B4; + GL_MULTISAMPLE_BIT_3DFX = $20000000; + // GL_3DFX_texture_compression_FXT1 + GL_COMPRESSED_RGB_FXT1_3DFX = $86B0; + GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1; + // GL_APPLE_client_storage + GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2; + // GL_APPLE_element_array + GL_ELEMENT_ARRAY_APPLE = $8A0C; + GL_ELEMENT_ARRAY_TYPE_APPLE = $8A0D; + GL_ELEMENT_ARRAY_POINTER_APPLE = $8A0E; + // GL_APPLE_fence + GL_DRAW_PIXELS_APPLE = $8A0A; + GL_FENCE_APPLE = $8A0B; + // GL_APPLE_specular_vector + GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0; + // GL_APPLE_transform_hint + GL_TRANSFORM_HINT_APPLE = $85B1; + // GL_APPLE_vertex_array_object + GL_VERTEX_ARRAY_BINDING_APPLE = $85B5; + // GL_APPLE_vertex_array_range + GL_VERTEX_ARRAY_RANGE_APPLE = $851D; + GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E; + GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F; + GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521; + GL_STORAGE_CLIENT_APPLE = $85B4; + GL_STORAGE_CACHED_APPLE = $85BE; + GL_STORAGE_SHARED_APPLE = $85BF; + // GL_APPLE_ycbcr_422 + GL_YCBCR_422_APPLE = $85B9; + GL_UNSIGNED_SHORT_8_8_APPLE = $85BA; + GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB; + GL_RGB_RAW_422_APPLE = $8A51; + // GL_APPLE_texture_range + GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7; + GL_TEXTURE_RANGE_POINTER_APPLE = $85B8; + GL_TEXTURE_STORAGE_HINT_APPLE = $85BC; + GL_STORAGE_PRIVATE_APPLE = $85BD; + // GL_APPLE_float_pixels + GL_HALF_APPLE = $140B; + GL_RGBA_FLOAT32_APPLE = $8814; + GL_RGB_FLOAT32_APPLE = $8815; + GL_ALPHA_FLOAT32_APPLE = $8816; + GL_INTENSITY_FLOAT32_APPLE = $8817; + GL_LUMINANCE_FLOAT32_APPLE = $8818; + GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819; + GL_RGBA_FLOAT16_APPLE = $881A; + GL_RGB_FLOAT16_APPLE = $881B; + GL_ALPHA_FLOAT16_APPLE = $881C; + GL_INTENSITY_FLOAT16_APPLE = $881D; + GL_LUMINANCE_FLOAT16_APPLE = $881E; + GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F; + GL_COLOR_FLOAT_APPLE = $8A0F; + // GL_APPLE_vertex_program_evaluators + GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00; + GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01; + GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02; + GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03; + GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04; + GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05; + GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06; + GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07; + GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08; + GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09; + // GL_APPLE_aux_depth_stencil + GL_AUX_DEPTH_STENCIL_APPLE = $8A14; + // GL_APPLE_object_purgeable + GL_BUFFER_OBJECT_APPLE = $85B3; + GL_RELEASED_APPLE = $8A19; + GL_VOLATILE_APPLE = $8A1A; + GL_RETAINED_APPLE = $8A1B; + GL_UNDEFINED_APPLE = $8A1C; + GL_PURGEABLE_APPLE = $8A1D; + // GL_APPLE_row_bytes + GL_PACK_ROW_BYTES_APPLE = $8A15; + GL_UNPACK_ROW_BYTES_APPLE = $8A16; + // GL_ARB_depth_texture + GL_DEPTH_COMPONENT16_ARB = $81A5; + GL_DEPTH_COMPONENT24_ARB = $81A6; + GL_DEPTH_COMPONENT32_ARB = $81A7; + GL_TEXTURE_DEPTH_SIZE_ARB = $884A; + GL_DEPTH_TEXTURE_MODE_ARB = $884B; + // GL_ARB_fragment_program + GL_FRAGMENT_PROGRAM_ARB = $8804; + GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805; + GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806; + GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807; + GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808; + GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809; + GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A; + GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B; + GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C; + GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D; + GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E; + GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F; + GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810; + GL_MAX_TEXTURE_COORDS_ARB = $8871; + GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872; + // GL_ARB_imaging + GL_CONSTANT_COLOR_ARB = $8001; + GL_ONE_MINUS_CONSTANT_COLOR = $8002; + GL_CONSTANT_ALPHA = $8003; + GL_ONE_MINUS_CONSTANT_ALPHA = $8004; + GL_BLEND_COLOR = $8005; + GL_FUNC_ADD = $8006; + GL_MIN = $8007; + GL_MAX = $8008; + GL_BLEND_EQUATION = $8009; + GL_FUNC_SUBTRACT = $800A; + GL_FUNC_REVERSE_SUBTRACT = $800B; + GL_CONVOLUTION_1D = $8010; + GL_CONVOLUTION_2D = $8011; + GL_SEPARABLE_2D = $8012; + GL_CONVOLUTION_BORDER_MODE = $8013; + GL_CONVOLUTION_FILTER_SCALE = $8014; + GL_CONVOLUTION_FILTER_BIAS = $8015; + GL_REDUCE = $8016; + GL_CONVOLUTION_FORMAT = $8017; + GL_CONVOLUTION_WIDTH = $8018; + GL_CONVOLUTION_HEIGHT = $8019; + GL_MAX_CONVOLUTION_WIDTH = $801A; + GL_MAX_CONVOLUTION_HEIGHT = $801B; + GL_POST_CONVOLUTION_RED_SCALE = $801C; + GL_POST_CONVOLUTION_GREEN_SCALE = $801D; + GL_POST_CONVOLUTION_BLUE_SCALE = $801E; + GL_POST_CONVOLUTION_ALPHA_SCALE = $801F; + GL_POST_CONVOLUTION_RED_BIAS = $8020; + GL_POST_CONVOLUTION_GREEN_BIAS = $8021; + GL_POST_CONVOLUTION_BLUE_BIAS = $8022; + GL_POST_CONVOLUTION_ALPHA_BIAS = $8023; + GL_HISTOGRAM = $8024; + GL_PROXY_HISTOGRAM = $8025; + GL_HISTOGRAM_WIDTH = $8026; + GL_HISTOGRAM_FORMAT = $8027; + GL_HISTOGRAM_RED_SIZE = $8028; + GL_HISTOGRAM_GREEN_SIZE = $8029; + GL_HISTOGRAM_BLUE_SIZE = $802A; + GL_HISTOGRAM_ALPHA_SIZE = $802B; + GL_HISTOGRAM_LUMINANCE_SIZE = $802C; + GL_HISTOGRAM_SINK = $802D; + GL_MINMAX = $802E; + GL_MINMAX_FORMAT = $802F; + GL_MINMAX_SINK = $8030; + GL_TABLE_TOO_LARGE = $8031; + GL_COLOR_MATRIX = $80B1; + GL_COLOR_MATRIX_STACK_DEPTH = $80B2; + GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3; + GL_POST_COLOR_MATRIX_RED_SCALE = $80B4; + GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5; + GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6; + GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7; + GL_POST_COLOR_MATRIX_RED_BIAS = $80B8; + GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9; + GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA; + GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB; + GL_COLOR_TABLE = $80D0; + GL_POST_CONVOLUTION_COLOR_TABLE = $80D1; + GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2; + GL_PROXY_COLOR_TABLE = $80D3; + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4; + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5; + GL_COLOR_TABLE_SCALE = $80D6; + GL_COLOR_TABLE_BIAS = $80D7; + GL_COLOR_TABLE_FORMAT = $80D8; + GL_COLOR_TABLE_WIDTH = $80D9; + GL_COLOR_TABLE_RED_SIZE = $80DA; + GL_COLOR_TABLE_GREEN_SIZE = $80DB; + GL_COLOR_TABLE_BLUE_SIZE = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE = $80DF; + GL_CONSTANT_BORDER = $8151; + GL_REPLICATE_BORDER = $8153; + GL_CONVOLUTION_BORDER_COLOR = $8154; + // GL_ARB_matrix_palette + GL_MATRIX_PALETTE_ARB = $8840; + GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841; + GL_MAX_PALETTE_MATRICES_ARB = $8842; + GL_CURRENT_PALETTE_MATRIX_ARB = $8843; + GL_MATRIX_INDEX_ARRAY_ARB = $8844; + GL_CURRENT_MATRIX_INDEX_ARB = $8845; + GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846; + GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847; + GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848; + GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849; + // GL_ARB_multisample + GL_MULTISAMPLE_ARB = $809D; + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E; + GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F; + GL_SAMPLE_COVERAGE_ARB = $80A0; + GL_SAMPLE_BUFFERS_ARB = $80A8; + GL_SAMPLES_ARB = $80A9; + GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA; + GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB; + GL_MULTISAMPLE_BIT_ARB = $20000000; + // GL_ARB_multitexture + GL_TEXTURE0_ARB = $84C0; + GL_TEXTURE1_ARB = $84C1; + GL_TEXTURE2_ARB = $84C2; + GL_TEXTURE3_ARB = $84C3; + GL_TEXTURE4_ARB = $84C4; + GL_TEXTURE5_ARB = $84C5; + GL_TEXTURE6_ARB = $84C6; + GL_TEXTURE7_ARB = $84C7; + GL_TEXTURE8_ARB = $84C8; + GL_TEXTURE9_ARB = $84C9; + GL_TEXTURE10_ARB = $84CA; + GL_TEXTURE11_ARB = $84CB; + GL_TEXTURE12_ARB = $84CC; + GL_TEXTURE13_ARB = $84CD; + GL_TEXTURE14_ARB = $84CE; + GL_TEXTURE15_ARB = $84CF; + GL_TEXTURE16_ARB = $84D0; + GL_TEXTURE17_ARB = $84D1; + GL_TEXTURE18_ARB = $84D2; + GL_TEXTURE19_ARB = $84D3; + GL_TEXTURE20_ARB = $84D4; + GL_TEXTURE21_ARB = $84D5; + GL_TEXTURE22_ARB = $84D6; + GL_TEXTURE23_ARB = $84D7; + GL_TEXTURE24_ARB = $84D8; + GL_TEXTURE25_ARB = $84D9; + GL_TEXTURE26_ARB = $84DA; + GL_TEXTURE27_ARB = $84DB; + GL_TEXTURE28_ARB = $84DC; + GL_TEXTURE29_ARB = $84DD; + GL_TEXTURE30_ARB = $84DE; + GL_TEXTURE31_ARB = $84DF; + GL_ACTIVE_TEXTURE_ARB = $84E0; + GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1; + GL_MAX_TEXTURE_UNITS_ARB = $84E2; + // GL_ARB_point_parameters + GL_POINT_SIZE_MIN_ARB = $8126; + GL_POINT_SIZE_MAX_ARB = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128; + GL_POINT_DISTANCE_ATTENUATION_ARB = $8129; + // GL_ARB_shadow + GL_TEXTURE_COMPARE_MODE_ARB = $884C; + GL_TEXTURE_COMPARE_FUNC_ARB = $884D; + GL_COMPARE_R_TO_TEXTURE_ARB = $884E; + // GL_ARB_shadow_ambient + GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF; + // GL_ARB_sparse_buffer + GL_SPARSE_STORAGE_BIT_ARB = $0400; + GL_SPARSE_BUFFER_PAGE_SIZE_ARB = $82F8; + // GL_ARB_texture_border_clamp + GL_CLAMP_TO_BORDER_ARB = $812D; + // GL_ARB_texture_compression + GL_COMPRESSED_ALPHA_ARB = $84E9; + GL_COMPRESSED_LUMINANCE_ARB = $84EA; + GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB; + GL_COMPRESSED_INTENSITY_ARB = $84EC; + GL_COMPRESSED_RGB_ARB = $84ED; + GL_COMPRESSED_RGBA_ARB = $84EE; + GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF; + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0; + GL_TEXTURE_COMPRESSED_ARB = $86A1; + GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2; + GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3; + // GL_ARB_texture_cube_map + GL_NORMAL_MAP_ARB = $8511; + GL_REFLECTION_MAP_ARB = $8512; + GL_TEXTURE_CUBE_MAP_ARB = $8513; + GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514; + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A; + GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C; + // GL_ARB_texture_env_combine + GL_COMBINE_ARB = $8570; + GL_COMBINE_RGB_ARB = $8571; + GL_COMBINE_ALPHA_ARB = $8572; + GL_SOURCE0_RGB_ARB = $8580; + GL_SOURCE1_RGB_ARB = $8581; + GL_SOURCE2_RGB_ARB = $8582; + GL_SOURCE0_ALPHA_ARB = $8588; + GL_SOURCE1_ALPHA_ARB = $8589; + GL_SOURCE2_ALPHA_ARB = $858A; + GL_OPERAND0_RGB_ARB = $8590; + GL_OPERAND1_RGB_ARB = $8591; + GL_OPERAND2_RGB_ARB = $8592; + GL_OPERAND0_ALPHA_ARB = $8598; + GL_OPERAND1_ALPHA_ARB = $8599; + GL_OPERAND2_ALPHA_ARB = $859A; + GL_RGB_SCALE_ARB = $8573; + GL_ADD_SIGNED_ARB = $8574; + GL_INTERPOLATE_ARB = $8575; + GL_SUBTRACT_ARB = $84E7; + GL_CONSTANT_ARB = $8576; + GL_PRIMARY_COLOR_ARB = $8577; + GL_PREVIOUS_ARB = $8578; + // GL_ARB_texture_env_dot3 + GL_DOT3_RGB_ARB = $86AE; + GL_DOT3_RGBA_ARB = $86AF; + // GL_ARB_texture_mirrored_repeat + GL_MIRRORED_REPEAT_ARB = $8370; + // GL_ARB_transpose_matrix + GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3; + GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4; + GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5; + GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6; + // GL_ARB_vertex_blend + GL_MAX_VERTEX_UNITS_ARB = $86A4; + GL_ACTIVE_VERTEX_UNITS_ARB = $86A5; + GL_WEIGHT_SUM_UNITY_ARB = $86A6; + GL_VERTEX_BLEND_ARB = $86A7; + GL_CURRENT_WEIGHT_ARB = $86A8; + GL_WEIGHT_ARRAY_TYPE_ARB = $86A9; + GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA; + GL_WEIGHT_ARRAY_SIZE_ARB = $86AB; + GL_WEIGHT_ARRAY_POINTER_ARB = $86AC; + GL_WEIGHT_ARRAY_ARB = $86AD; + GL_MODELVIEW0_ARB = $1700; + GL_MODELVIEW1_ARB = $850A; + GL_MODELVIEW2_ARB = $8722; + GL_MODELVIEW3_ARB = $8723; + GL_MODELVIEW4_ARB = $8724; + GL_MODELVIEW5_ARB = $8725; + GL_MODELVIEW6_ARB = $8726; + GL_MODELVIEW7_ARB = $8727; + GL_MODELVIEW8_ARB = $8728; + GL_MODELVIEW9_ARB = $8729; + GL_MODELVIEW10_ARB = $872A; + GL_MODELVIEW11_ARB = $872B; + GL_MODELVIEW12_ARB = $872C; + GL_MODELVIEW13_ARB = $872D; + GL_MODELVIEW14_ARB = $872E; + GL_MODELVIEW15_ARB = $872F; + GL_MODELVIEW16_ARB = $8730; + GL_MODELVIEW17_ARB = $8731; + GL_MODELVIEW18_ARB = $8732; + GL_MODELVIEW19_ARB = $8733; + GL_MODELVIEW20_ARB = $8734; + GL_MODELVIEW21_ARB = $8735; + GL_MODELVIEW22_ARB = $8736; + GL_MODELVIEW23_ARB = $8737; + GL_MODELVIEW24_ARB = $8738; + GL_MODELVIEW25_ARB = $8739; + GL_MODELVIEW26_ARB = $873A; + GL_MODELVIEW27_ARB = $873B; + GL_MODELVIEW28_ARB = $873C; + GL_MODELVIEW29_ARB = $873D; + GL_MODELVIEW30_ARB = $873E; + GL_MODELVIEW31_ARB = $873F; + // GL_ARB_vertex_buffer_object + GL_BUFFER_SIZE_ARB = $8764; + GL_BUFFER_USAGE_ARB = $8765; + GL_ARRAY_BUFFER_ARB = $8892; + GL_ELEMENT_ARRAY_BUFFER_ARB = $8893; + GL_ARRAY_BUFFER_BINDING_ARB = $8894; + GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895; + GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896; + GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897; + GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898; + GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899; + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A; + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B; + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C; + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D; + GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E; + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F; + GL_READ_ONLY_ARB = $88B8; + GL_WRITE_ONLY_ARB = $88B9; + GL_READ_WRITE_ARB = $88BA; + GL_BUFFER_ACCESS_ARB = $88BB; + GL_BUFFER_MAPPED_ARB = $88BC; + GL_BUFFER_MAP_POINTER_ARB = $88BD; + GL_STREAM_DRAW_ARB = $88E0; + GL_STREAM_READ_ARB = $88E1; + GL_STREAM_COPY_ARB = $88E2; + GL_STATIC_DRAW_ARB = $88E4; + GL_STATIC_READ_ARB = $88E5; + GL_STATIC_COPY_ARB = $88E6; + GL_DYNAMIC_DRAW_ARB = $88E8; + GL_DYNAMIC_READ_ARB = $88E9; + GL_DYNAMIC_COPY_ARB = $88EA; + // GL_ARB_vertex_program + GL_COLOR_SUM_ARB = $8458; + GL_VERTEX_PROGRAM_ARB = $8620; + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622; + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623; + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624; + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625; + GL_CURRENT_VERTEX_ATTRIB_ARB = $8626; + GL_PROGRAM_LENGTH_ARB = $8627; + GL_PROGRAM_STRING_ARB = $8628; + GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E; + GL_MAX_PROGRAM_MATRICES_ARB = $862F; + GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640; + GL_CURRENT_MATRIX_ARB = $8641; + GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642; + GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643; + GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645; + GL_PROGRAM_ERROR_POSITION_ARB = $864B; + GL_PROGRAM_BINDING_ARB = $8677; + GL_MAX_VERTEX_ATTRIBS_ARB = $8869; + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A; + GL_PROGRAM_ERROR_STRING_ARB = $8874; + GL_PROGRAM_FORMAT_ASCII_ARB = $8875; + GL_PROGRAM_FORMAT_ARB = $8876; + GL_PROGRAM_INSTRUCTIONS_ARB = $88A0; + GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1; + GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2; + GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3; + GL_PROGRAM_TEMPORARIES_ARB = $88A4; + GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5; + GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6; + GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7; + GL_PROGRAM_PARAMETERS_ARB = $88A8; + GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9; + GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA; + GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB; + GL_PROGRAM_ATTRIBS_ARB = $88AC; + GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD; + GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE; + GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF; + GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0; + GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1; + GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2; + GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3; + GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4; + GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5; + GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6; + GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7; + GL_MATRIX0_ARB = $88C0; + GL_MATRIX1_ARB = $88C1; + GL_MATRIX2_ARB = $88C2; + GL_MATRIX3_ARB = $88C3; + GL_MATRIX4_ARB = $88C4; + GL_MATRIX5_ARB = $88C5; + GL_MATRIX6_ARB = $88C6; + GL_MATRIX7_ARB = $88C7; + GL_MATRIX8_ARB = $88C8; + GL_MATRIX9_ARB = $88C9; + GL_MATRIX10_ARB = $88CA; + GL_MATRIX11_ARB = $88CB; + GL_MATRIX12_ARB = $88CC; + GL_MATRIX13_ARB = $88CD; + GL_MATRIX14_ARB = $88CE; + GL_MATRIX15_ARB = $88CF; + GL_MATRIX16_ARB = $88D0; + GL_MATRIX17_ARB = $88D1; + GL_MATRIX18_ARB = $88D2; + GL_MATRIX19_ARB = $88D3; + GL_MATRIX20_ARB = $88D4; + GL_MATRIX21_ARB = $88D5; + GL_MATRIX22_ARB = $88D6; + GL_MATRIX23_ARB = $88D7; + GL_MATRIX24_ARB = $88D8; + GL_MATRIX25_ARB = $88D9; + GL_MATRIX26_ARB = $88DA; + GL_MATRIX27_ARB = $88DB; + GL_MATRIX28_ARB = $88DC; + GL_MATRIX29_ARB = $88DD; + GL_MATRIX30_ARB = $88DE; + GL_MATRIX31_ARB = $88DF; + + // GL_ARB_draw_buffers + GL_MAX_DRAW_BUFFERS_ARB = $8824; + GL_DRAW_BUFFER0_ARB = $8825; + GL_DRAW_BUFFER1_ARB = $8826; + GL_DRAW_BUFFER2_ARB = $8827; + GL_DRAW_BUFFER3_ARB = $8828; + GL_DRAW_BUFFER4_ARB = $8829; + GL_DRAW_BUFFER5_ARB = $882A; + GL_DRAW_BUFFER6_ARB = $882B; + GL_DRAW_BUFFER7_ARB = $882C; + GL_DRAW_BUFFER8_ARB = $882D; + GL_DRAW_BUFFER9_ARB = $882E; + GL_DRAW_BUFFER10_ARB = $882F; + GL_DRAW_BUFFER11_ARB = $8830; + GL_DRAW_BUFFER12_ARB = $8831; + GL_DRAW_BUFFER13_ARB = $8832; + GL_DRAW_BUFFER14_ARB = $8833; + GL_DRAW_BUFFER15_ARB = $8834; + // GL_ARB_texture_rectangle + GL_TEXTURE_RECTANGLE_ARB = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8; + // GL_ARB_color_buffer_float + GL_RGBA_FLOAT_MODE_ARB = $8820; + GL_CLAMP_VERTEX_COLOR_ARB = $891A; + GL_CLAMP_FRAGMENT_COLOR_ARB = $891B; + GL_CLAMP_READ_COLOR_ARB = $891C; + GL_FIXED_ONLY_ARB = $891D; + WGL_TYPE_RGBA_FLOAT_ARB = $21A0; + GLX_RGBA_FLOAT_TYPE = $20B9; + GLX_RGBA_FLOAT_BIT = $00000004; + // GL_ARB_compute_variable_group_size + GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = $9344; + GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = $90EB; + GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = $9345; + GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = $91BF; + // GL_ARB_half_float_pixel + GL_HALF_FLOAT_ARB = $140B; + // GL_ARB_texture_float + GL_TEXTURE_RED_TYPE_ARB = $8C10; + GL_TEXTURE_GREEN_TYPE_ARB = $8C11; + GL_TEXTURE_BLUE_TYPE_ARB = $8C12; + GL_TEXTURE_ALPHA_TYPE_ARB = $8C13; + GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14; + GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15; + GL_TEXTURE_DEPTH_TYPE_ARB = $8C16; + GL_UNSIGNED_NORMALIZED_ARB = $8C17; + GL_RGBA32F_ARB = $8814; + GL_RGB32F_ARB = $8815; + GL_ALPHA32F_ARB = $8816; + GL_INTENSITY32F_ARB = $8817; + GL_LUMINANCE32F_ARB = $8818; + GL_LUMINANCE_ALPHA32F_ARB = $8819; + GL_RGBA16F_ARB = $881A; + GL_RGB16F_ARB = $881B; + GL_ALPHA16F_ARB = $881C; + GL_INTENSITY16F_ARB = $881D; + GL_LUMINANCE16F_ARB = $881E; + GL_LUMINANCE_ALPHA16F_ARB = $881F; + // GL_ARB_pixel_buffer_object + GL_PIXEL_PACK_BUFFER_ARB = $88EB; + GL_PIXEL_UNPACK_BUFFER_ARB = $88EC; + GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED; + GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF; + // GL_ARB_depth_buffer_float + GL_DEPTH_COMPONENT32F = $8CAC; + GL_DEPTH32F_STENCIL8 = $8CAD; + GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD; + // GL_ARB_framebuffer_object + GL_INVALID_FRAMEBUFFER_OPERATION = $0506; + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210; + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211; + GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212; + GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213; + GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214; + GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215; + GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216; + GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217; + GL_FRAMEBUFFER_DEFAULT = $8218; + GL_FRAMEBUFFER_UNDEFINED = $8219; + GL_DEPTH_STENCIL_ATTACHMENT = $821A; + GL_MAX_RENDERBUFFER_SIZE = $84E8; + GL_DEPTH_STENCIL = $84F9; + GL_UNSIGNED_INT_24_8 = $84FA; + GL_DEPTH24_STENCIL8 = $88F0; + GL_TEXTURE_STENCIL_SIZE = $88F1; + GL_TEXTURE_RED_TYPE = $8C10; + GL_TEXTURE_GREEN_TYPE = $8C11; + GL_TEXTURE_BLUE_TYPE = $8C12; + GL_TEXTURE_ALPHA_TYPE = $8C13; + GL_TEXTURE_DEPTH_TYPE = $8C16; + GL_UNSIGNED_NORMALIZED = $8C17; + GL_FRAMEBUFFER_BINDING = $8CA6; + GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING; + GL_RENDERBUFFER_BINDING = $8CA7; + GL_READ_FRAMEBUFFER = $8CA8; + GL_DRAW_FRAMEBUFFER = $8CA9; + GL_READ_FRAMEBUFFER_BINDING = $8CAA; + GL_RENDERBUFFER_SAMPLES = $8CAB; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4; + GL_FRAMEBUFFER_COMPLETE = $8CD5; + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6; + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7; + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB; + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC; + GL_FRAMEBUFFER_UNSUPPORTED = $8CDD; + GL_MAX_COLOR_ATTACHMENTS = $8CDF; + GL_COLOR_ATTACHMENT0 = $8CE0; + GL_COLOR_ATTACHMENT1 = $8CE1; + GL_COLOR_ATTACHMENT2 = $8CE2; + GL_COLOR_ATTACHMENT3 = $8CE3; + GL_COLOR_ATTACHMENT4 = $8CE4; + GL_COLOR_ATTACHMENT5 = $8CE5; + GL_COLOR_ATTACHMENT6 = $8CE6; + GL_COLOR_ATTACHMENT7 = $8CE7; + GL_COLOR_ATTACHMENT8 = $8CE8; + GL_COLOR_ATTACHMENT9 = $8CE9; + GL_COLOR_ATTACHMENT10 = $8CEA; + GL_COLOR_ATTACHMENT11 = $8CEB; + GL_COLOR_ATTACHMENT12 = $8CEC; + GL_COLOR_ATTACHMENT13 = $8CED; + GL_COLOR_ATTACHMENT14 = $8CEE; + GL_COLOR_ATTACHMENT15 = $8CEF; + GL_DEPTH_ATTACHMENT = $8D00; + GL_STENCIL_ATTACHMENT = $8D20; + GL_FRAMEBUFFER = $8D40; + GL_RENDERBUFFER = $8D41; + GL_RENDERBUFFER_WIDTH = $8D42; + GL_RENDERBUFFER_HEIGHT = $8D43; + GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44; + GL_STENCIL_INDEX1 = $8D46; + GL_STENCIL_INDEX4 = $8D47; + GL_STENCIL_INDEX8 = $8D48; + GL_STENCIL_INDEX16 = $8D49; + GL_RENDERBUFFER_RED_SIZE = $8D50; + GL_RENDERBUFFER_GREEN_SIZE = $8D51; + GL_RENDERBUFFER_BLUE_SIZE = $8D52; + GL_RENDERBUFFER_ALPHA_SIZE = $8D53; + GL_RENDERBUFFER_DEPTH_SIZE = $8D54; + GL_RENDERBUFFER_STENCIL_SIZE = $8D55; + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56; + GL_MAX_SAMPLES = $8D57; + GL_INDEX = $8222; + GL_TEXTURE_LUMINANCE_TYPE = $8C14; + GL_TEXTURE_INTENSITY_TYPE = $8C15; + // GL_ARB_framebuffer_sRGB + GL_FRAMEBUFFER_SRGB = $8DB9; + // GL_ARB_geometry_shader4 + GL_LINES_ADJACENCY_ARB = $000A; + GL_LINE_STRIP_ADJACENCY_ARB = $000B; + GL_TRIANGLES_ADJACENCY_ARB = $000C; + GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D; + GL_PROGRAM_POINT_SIZE_ARB = $8642; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9; + GL_GEOMETRY_SHADER_ARB = $8DD9; + GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA; + GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB; + GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC; + GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD; + GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1; + // GL_ARB_half_float_vertex + GL_HALF_FLOAT = $140B; + // GL_ARB_instanced_arrays + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE; + // GL_ARB_map_buffer_range + GL_MAP_READ_BIT = $0001; + GL_MAP_WRITE_BIT = $0002; + GL_MAP_INVALIDATE_RANGE_BIT = $0004; + GL_MAP_INVALIDATE_BUFFER_BIT = $0008; + GL_MAP_FLUSH_EXPLICIT_BIT = $0010; + GL_MAP_UNSYNCHRONIZED_BIT = $0020; + // GL_ARB_texture_buffer_object + GL_TEXTURE_BUFFER_ARB = $8C2A; + GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B; + GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C; + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D; + GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E; + // GL_ARB_texture_compression_rgtc + GL_COMPRESSED_RED_RGTC1 = $8DBB; + GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC; + GL_COMPRESSED_RG_RGTC2 = $8DBD; + GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE; + // GL_ARB_texture_rg + GL_RG = $8227; + GL_RG_INTEGER = $8228; + GL_R8 = $8229; + GL_R16 = $822A; + GL_RG8 = $822B; + GL_RG16 = $822C; + GL_R16F = $822D; + GL_R32F = $822E; + GL_RG16F = $822F; + GL_RG32F = $8230; + GL_R8I = $8231; + GL_R8UI = $8232; + GL_R16I = $8233; + GL_R16UI = $8234; + GL_R32I = $8235; + GL_R32UI = $8236; + GL_RG8I = $8237; + GL_RG8UI = $8238; + GL_RG16I = $8239; + GL_RG16UI = $823A; + GL_RG32I = $823B; + GL_RG32UI = $823C; + // GL_ARB_vertex_array_object + GL_VERTEX_ARRAY_BINDING = $85B5; + // GL_ARB_uniform_buffer_object + GL_UNIFORM_BUFFER = $8A11; + GL_UNIFORM_BUFFER_BINDING = $8A28; + GL_UNIFORM_BUFFER_START = $8A29; + GL_UNIFORM_BUFFER_SIZE = $8A2A; + GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B; + GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C; + GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D; + GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E; + GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F; + GL_MAX_UNIFORM_BLOCK_SIZE = $8A30; + GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31; + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32; + GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33; + GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34; + GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35; + GL_ACTIVE_UNIFORM_BLOCKS = $8A36; + GL_UNIFORM_TYPE = $8A37; + GL_UNIFORM_SIZE = $8A38; + GL_UNIFORM_NAME_LENGTH = $8A39; + GL_UNIFORM_BLOCK_INDEX = $8A3A; + GL_UNIFORM_OFFSET = $8A3B; + GL_UNIFORM_ARRAY_STRIDE = $8A3C; + GL_UNIFORM_MATRIX_STRIDE = $8A3D; + GL_UNIFORM_IS_ROW_MAJOR = $8A3E; + GL_UNIFORM_BLOCK_BINDING = $8A3F; + GL_UNIFORM_BLOCK_DATA_SIZE = $8A40; + GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41; + GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42; + GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43; + GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44; + GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = $8A45; + GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46; + GL_INVALID_INDEX = $FFFFFFFF; + // GL_ARB_copy_buffer + GL_COPY_READ_BUFFER_BINDING = $8F36; + GL_COPY_READ_BUFFER = GL_COPY_READ_BUFFER_BINDING; + GL_COPY_WRITE_BUFFER_BINDING = $8F37; + GL_COPY_WRITE_BUFFER = GL_COPY_WRITE_BUFFER_BINDING; + // GL_ARB_depth_clamp + GL_DEPTH_CLAMP = $864F; + // GL_ARB_provoking_vertex + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C; + GL_FIRST_VERTEX_CONVENTION = $8E4D; + GL_LAST_VERTEX_CONVENTION = $8E4E; + GL_PROVOKING_VERTEX = $8E4F; + // GL_ARB_seamless_cube_map + GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F; + // GL_ARB_sync + GL_MAX_SERVER_WAIT_TIMEOUT = $9111; + GL_OBJECT_TYPE = $9112; + GL_SYNC_CONDITION = $9113; + GL_SYNC_STATUS = $9114; + GL_SYNC_FLAGS = $9115; + GL_SYNC_FENCE = $9116; + GL_SYNC_GPU_COMMANDS_COMPLETE = $9117; + GL_UNSIGNALED = $9118; + GL_SIGNALED = $9119; + GL_ALREADY_SIGNALED = $911A; + GL_TIMEOUT_EXPIRED = $911B; + GL_CONDITION_SATISFIED = $911C; + GL_WAIT_FAILED = $911D; + GL_SYNC_FLUSH_COMMANDS_BIT = $00000001; + GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF; + // GL_ARB_texture_multisample + GL_SAMPLE_POSITION = $8E50; + GL_SAMPLE_MASK = $8E51; + GL_SAMPLE_MASK_VALUE = $8E52; + GL_MAX_SAMPLE_MASK_WORDS = $8E59; + GL_TEXTURE_2D_MULTISAMPLE = $9100; + GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101; + GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102; + GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103; + GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104; + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105; + GL_TEXTURE_SAMPLES = $9106; + GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107; + GL_SAMPLER_2D_MULTISAMPLE = $9108; + GL_INT_SAMPLER_2D_MULTISAMPLE = $9109; + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A; + GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B; + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C; + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D; + GL_MAX_COLOR_TEXTURE_SAMPLES = $910E; + GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F; + GL_MAX_INTEGER_SAMPLES = $9110; + // GL_ARB_sample_shading + GL_SAMPLE_SHADING_ARB = $8C36; + GL_MIN_SAMPLE_SHADING_VALUE_ARB = $8C37; + // GL_ARB_texture_cube_map_array + GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009; + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A; + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B; + GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C; + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D; + GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E; + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F; + // GL_ARB_texture_gather + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F; + // GL_ARB_shading_language_include + GL_SHADER_INCLUDE_ARB = $8DAE; + GL_NAMED_STRING_LENGTH_ARB = $8DE9; + GL_NAMED_STRING_TYPE_ARB = $8DEA; + // GL_ARB_texture_compression_bptc + GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C; + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D; + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E; + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F; + // GL_ARB_blend_func_extended + GL_SRC1_COLOR = $88F9; + GL_ONE_MINUS_SRC1_COLOR = $88FA; + GL_ONE_MINUS_SRC1_ALPHA = $88FB; + GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC; + // GL_ARB_occlusion_query2 + GL_ANY_SAMPLES_PASSED = $8C2F; + // GL_ARB_sampler_objects + GL_SAMPLER_BINDING = $8919; + // GL_ARB_texture_rgb10_a2ui + GL_RGB10_A2UI = $906F; + // GL_ARB_texture_swizzle + GL_TEXTURE_SWIZZLE_R = $8E42; + GL_TEXTURE_SWIZZLE_G = $8E43; + GL_TEXTURE_SWIZZLE_B = $8E44; + GL_TEXTURE_SWIZZLE_A = $8E45; + GL_TEXTURE_SWIZZLE_RGBA = $8E46; + // GL_ARB_SPARSE_TEXTURE + GL_TEXTURE_SPARSE_ARB = $91A6; + GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = $91A7; + GL_NUM_VIRTUAL_PAGE_SIZES_ARB = $91A8; + GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = $91A9; + GL_NUM_SPARSE_LEVELS_ARB = $91AA; + GL_VIRTUAL_PAGE_SIZE_X_ARB = $9195; + GL_VIRTUAL_PAGE_SIZE_Y_ARB = $9196; + GL_VIRTUAL_PAGE_SIZE_Z_ARB = $9197; + GL_MAX_SPARSE_TEXTURE_SIZE_ARB = $9198; + GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = $9199; + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = $919A; + GL_MIN_SPARSE_LEVEL_ARB = $919B; + // GL_ARB_timer_query + GL_TIME_ELAPSED = $88BF; + GL_TIMESTAMP = $8E28; + // GL_ARB_vertex_type_2_10_10_10_rev + GL_INT_2_10_10_10_REV = $8D9F; + // GL_ARB_draw_indirect + GL_DRAW_INDIRECT_BUFFER = $8F3F; + GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43; + // GL_ARB_gpu_shader5 + GL_GEOMETRY_SHADER_INVOCATIONS = $887F; + GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A; + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B; + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C; + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D; + // GL_ARB_gpu_shader_fp64 + GL_DOUBLE_VEC2 = $8FFC; + GL_DOUBLE_VEC3 = $8FFD; + GL_DOUBLE_VEC4 = $8FFE; + GL_DOUBLE_MAT2 = $8F46; + GL_DOUBLE_MAT3 = $8F47; + GL_DOUBLE_MAT4 = $8F48; + GL_DOUBLE_MAT2x3 = $8F49; + GL_DOUBLE_MAT2x4 = $8F4A; + GL_DOUBLE_MAT3x2 = $8F4B; + GL_DOUBLE_MAT3x4 = $8F4C; + GL_DOUBLE_MAT4x2 = $8F4D; + GL_DOUBLE_MAT4x3 = $8F4E; + // GL_ARB_shader_subroutine + GL_ACTIVE_SUBROUTINES = $8DE5; + GL_ACTIVE_SUBROUTINE_UNIFORMS = $8DE6; + GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = $8E47; + GL_ACTIVE_SUBROUTINE_MAX_LENGTH = $8E48; + GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = $8E49; + GL_MAX_SUBROUTINES = $8DE7; + GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = $8DE8; + GL_NUM_COMPATIBLE_SUBROUTINES = $8E4A; + GL_COMPATIBLE_SUBROUTINES = $8E4B; + // GL_ARB_tessellation_shader + GL_PATCHES = $000E; + GL_PATCH_VERTICES = $8E72; + GL_PATCH_DEFAULT_INNER_LEVEL = $8E73; + GL_PATCH_DEFAULT_OUTER_LEVEL = $8E74; + GL_TESS_CONTROL_OUTPUT_VERTICES = $8E75; + GL_TESS_GEN_MODE = $8E76; + GL_TESS_GEN_SPACING = $8E77; + GL_TESS_GEN_VERTEX_ORDER = $8E78; + GL_TESS_GEN_POINT_MODE = $8E79; + GL_ISOLINES = $8E7A; + GL_FRACTIONAL_ODD = $8E7B; + GL_FRACTIONAL_EVEN = $8E7C; + GL_MAX_PATCH_VERTICES = $8E7D; + GL_MAX_TESS_GEN_LEVEL = $8E7E; + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = $8E7F; + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E80; + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = $8E81; + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = $8E82; + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = $8E83; + GL_MAX_TESS_PATCH_COMPONENTS = $8E84; + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = $8E85; + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = $8E86; + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = $8E89; + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = $8E8A; + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = $886C; + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = $886D; + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = $8E1E; + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E1F; + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = $84F0; + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = $84F1; + GL_TESS_EVALUATION_SHADER = $8E87; + GL_TESS_CONTROL_SHADER = $8E88; + // GL_ARB_transform_feedback2 + GL_TRANSFORM_FEEDBACK = $8E22; + GL_TRANSFORM_FEEDBACK_PAUSED = $8E23; + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = GL_TRANSFORM_FEEDBACK_PAUSED; + GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24; + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = GL_TRANSFORM_FEEDBACK_ACTIVE; + GL_TRANSFORM_FEEDBACK_BINDING = $8E25; + // GL_ARB_transform_feedback_overflow_query + GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = $82EC; + GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = $82ED; + // GL_ARB_transform_feedback3 + GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = $8E70; + GL_MAX_VERTEX_STREAMS = $8E71; + // GL_ARB_ES2_compatibility + GL_FIXED = $140C; + GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A; + GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B; + GL_LOW_FLOAT = $8DF0; + GL_MEDIUM_FLOAT = $8DF1; + GL_HIGH_FLOAT = $8DF2; + GL_LOW_INT = $8DF3; + GL_MEDIUM_INT = $8DF4; + GL_HIGH_INT = $8DF5; + GL_SHADER_COMPILER = $8DFA; + GL_NUM_SHADER_BINARY_FORMATS = $8DF9; + GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB; + GL_MAX_VARYING_VECTORS = $8DFC; + GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD; + GL_RGB565 = $8D62; + // GL_ARB_get_program_binary + GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257; + GL_PROGRAM_BINARY_LENGTH = $8741; + GL_NUM_PROGRAM_BINARY_FORMATS = $87FE; + GL_PROGRAM_BINARY_FORMATS = $87FF; + // GL_ARB_separate_shader_objects + GL_VERTEX_SHADER_BIT = $00000001; + GL_FRAGMENT_SHADER_BIT = $00000002; + GL_GEOMETRY_SHADER_BIT = $00000004; + GL_TESS_CONTROL_SHADER_BIT = $00000008; + GL_TESS_EVALUATION_SHADER_BIT = $00000010; + GL_ALL_SHADER_BITS = $FFFFFFFF; + GL_PROGRAM_SEPARABLE = $8258; + GL_ACTIVE_PROGRAM = $8259; + GL_PROGRAM_PIPELINE_BINDING = $825A; + // GL_ARB_viewport_array + GL_MAX_VIEWPORTS = $825B; + GL_VIEWPORT_SUBPIXEL_BITS = $825C; + GL_VIEWPORT_BOUNDS_RANGE = $825D; + GL_LAYER_PROVOKING_VERTEX = $825E; + GL_VIEWPORT_INDEX_PROVOKING_VERTEX = $825F; + GL_UNDEFINED_VERTEX = $8260; + // GL_ARB_cl_event + GL_SYNC_CL_EVENT_ARB = $8240; + GL_SYNC_CL_EVENT_COMPLETE_ARB = $8241; + // GL_ARB_debug_output + GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = $8242; + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = $8243; + GL_DEBUG_CALLBACK_FUNCTION_ARB = $8244; + GL_DEBUG_CALLBACK_USER_PARAM_ARB = $8245; + GL_DEBUG_SOURCE_API_ARB = $8246; + GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = $8247; + GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = $8248; + GL_DEBUG_SOURCE_THIRD_PARTY_ARB = $8249; + GL_DEBUG_SOURCE_APPLICATION_ARB = $824A; + GL_DEBUG_SOURCE_OTHER_ARB = $824B; + GL_DEBUG_TYPE_ERROR_ARB = $824C; + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = $824D; + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = $824E; + GL_DEBUG_TYPE_PORTABILITY_ARB = $824F; + GL_DEBUG_TYPE_PERFORMANCE_ARB = $8250; + GL_DEBUG_TYPE_OTHER_ARB = $8251; + GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = $9143; + GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = $9144; + GL_DEBUG_LOGGED_MESSAGES_ARB = $9145; + GL_DEBUG_SEVERITY_HIGH_ARB = $9146; + GL_DEBUG_SEVERITY_MEDIUM_ARB = $9147; + GL_DEBUG_SEVERITY_LOW_ARB = $9148; + // GL_ARB_robustness + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = $00000004; + GL_LOSE_CONTEXT_ON_RESET_ARB = $8252; + GL_GUILTY_CONTEXT_RESET_ARB = $8253; + GL_INNOCENT_CONTEXT_RESET_ARB = $8254; + GL_UNKNOWN_CONTEXT_RESET_ARB = $8255; + GL_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + GL_NO_RESET_NOTIFICATION_ARB = $8261; + // GL_ARB_compressed_texture_pixel_storage + GL_UNPACK_COMPRESSED_BLOCK_WIDTH = $09127; + GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = $09128; + GL_UNPACK_COMPRESSED_BLOCK_DEPTH = $09129; + GL_UNPACK_COMPRESSED_BLOCK_SIZE = $0912A; + GL_PACK_COMPRESSED_BLOCK_WIDTH = $0912B; + GL_PACK_COMPRESSED_BLOCK_HEIGHT = $0912C; + GL_PACK_COMPRESSED_BLOCK_DEPTH = $0912D; + GL_PACK_COMPRESSED_BLOCK_SIZE = $0912E; + // GL_ARB_internalformat_query + GL_NUM_SAMPLE_COUNTS = $09380; + // GL_ARB_map_buffer_alignment + GL_MIN_MAP_BUFFER_ALIGNMENT = $090BC; + // GL_ARB_shader_atomic_counters + GL_ATOMIC_COUNTER_BUFFER = $92C0; + GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1; + GL_ATOMIC_COUNTER_BUFFER_START = $92C2; + GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3; + GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = $92C4; + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = $92C5; + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = $92C6; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = $92C7; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = $92C8; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = $92C9; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = $92CA; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = $92CB; + GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC; + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD; + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE; + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF; + GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0; + GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1; + GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2; + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3; + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4; + GL_MAX_GEOMETRY_ATOMIC_COUNTERS = $92D5; + GL_MAX_FRAGMENT_ATOMIC_COUNTERS = $92D6; + GL_MAX_COMBINED_ATOMIC_COUNTERS = $92D7; + GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8; + GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC; + GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = $92D9; + GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = $92DA; + GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB; + // GL_ARB_shader_image_load_store + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001; + GL_ELEMENT_ARRAY_BARRIER_BIT = $00000002; + GL_UNIFORM_BARRIER_BIT = $00000004; + GL_TEXTURE_FETCH_BARRIER_BIT = $00000008; + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020; + GL_COMMAND_BARRIER_BIT = $00000040; + GL_PIXEL_BUFFER_BARRIER_BIT = $00000080; + GL_TEXTURE_UPDATE_BARRIER_BIT = $00000100; + GL_BUFFER_UPDATE_BARRIER_BIT = $00000200; + GL_FRAMEBUFFER_BARRIER_BIT = $00000400; + GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800; + GL_ATOMIC_COUNTER_BARRIER_BIT = $00001000; + GL_ALL_BARRIER_BITS = $FFFFFFFF; + GL_MAX_IMAGE_UNITS = $8F38; + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = $8F39; + GL_IMAGE_BINDING_NAME = $8F3A; + GL_IMAGE_BINDING_LEVEL = $8F3B; + GL_IMAGE_BINDING_LAYERED = $8F3C; + GL_IMAGE_BINDING_LAYER = $8F3D; + GL_IMAGE_BINDING_ACCESS = $8F3E; + GL_IMAGE_1D = $904C; + GL_IMAGE_2D = $904D; + GL_IMAGE_3D = $904E; + GL_IMAGE_2D_RECT = $904F; + GL_IMAGE_CUBE = $9050; + GL_IMAGE_BUFFER = $9051; + GL_IMAGE_1D_ARRAY = $9052; + GL_IMAGE_2D_ARRAY = $9053; + GL_IMAGE_CUBE_MAP_ARRAY = $9054; + GL_IMAGE_2D_MULTISAMPLE = $9055; + GL_IMAGE_2D_MULTISAMPLE_ARRAY = $9056; + GL_INT_IMAGE_1D = $9057; + GL_INT_IMAGE_2D = $9058; + GL_INT_IMAGE_3D = $9059; + GL_INT_IMAGE_2D_RECT = $905A; + GL_INT_IMAGE_CUBE = $905B; + GL_INT_IMAGE_BUFFER = $905C; + GL_INT_IMAGE_1D_ARRAY = $905D; + GL_INT_IMAGE_2D_ARRAY = $905E; + GL_INT_IMAGE_CUBE_MAP_ARRAY = $905F; + GL_INT_IMAGE_2D_MULTISAMPLE = $9060; + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $9061; + GL_UNSIGNED_INT_IMAGE_1D = $9062; + GL_UNSIGNED_INT_IMAGE_2D = $9063; + GL_UNSIGNED_INT_IMAGE_3D = $9064; + GL_UNSIGNED_INT_IMAGE_2D_RECT = $9065; + GL_UNSIGNED_INT_IMAGE_CUBE = $9066; + GL_UNSIGNED_INT_IMAGE_BUFFER = $9067; + GL_UNSIGNED_INT_IMAGE_1D_ARRAY = $9068; + GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069; + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = $906B; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $906C; + GL_MAX_IMAGE_SAMPLES = $906D; + GL_IMAGE_BINDING_FORMAT = $906E; + GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7; + GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8; + GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9; + GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA; + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB; + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC; + GL_MAX_GEOMETRY_IMAGE_UNIFORMS = $90CD; + GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE; + GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF; + // GL_ARB_texture_storage + GL_TEXTURE_IMMUTABLE_FORMAT = $912F; + // 4.3 + // GL_KHR_texture_compression_astc_hdr + GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0; + GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1; + GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2; + GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3; + GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4; + GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5; + GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6; + GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7; + GL_COMPRESSED_RGBA_ASTC_105_KHR = $93B8; + GL_COMPRESSED_RGBA_ASTC_106_KHR = $93B9; + GL_COMPRESSED_RGBA_ASTC_108_KHR = $93BA; + GL_COMPRESSED_RGBA_ASTC_110_KHR = $93BB; + GL_COMPRESSED_RGBA_ASTC_12x10_KHR = $93BC; + GL_COMPRESSED_RGBA_ASTC_12x12_KHR = $93BD; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = $93D0; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = $93D1; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = $93D2; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = $93D3; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = $93D4; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = $93D5; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = $93D6; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = $93D7; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = $93D8; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = $93D9; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = $93DA; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = $93DB; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = $93DC; + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = $93DD; + // (4.3) GL_KHR_debug + GL_DEBUG_OUTPUT_SYNCHRONOUS = $8242; + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = $8243; + GL_DEBUG_CALLBACK_FUNCTION = $8244; + GL_DEBUG_CALLBACK_USER_PARAM = $8245; + GL_DEBUG_SOURCE_API = $8246; + GL_DEBUG_SOURCE_WINDOW_SYSTEM = $8247; + GL_DEBUG_SOURCE_SHADER_COMPILER = $8248; + GL_DEBUG_SOURCE_THIRD_PARTY = $8249; + GL_DEBUG_SOURCE_APPLICATION = $824A; + GL_DEBUG_SOURCE_OTHER = $824B; + GL_DEBUG_TYPE_ERROR = $824C; + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = $824D; + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = $824E; + GL_DEBUG_TYPE_PORTABILITY = $824F; + GL_DEBUG_TYPE_PERFORMANCE = $8250; + GL_DEBUG_TYPE_OTHER = $8251; + GL_DEBUG_TYPE_MARKER = $8268; + GL_DEBUG_TYPE_PUSH_GROUP = $8269; + GL_DEBUG_TYPE_POP_GROUP = $826A; + GL_DEBUG_SEVERITY_NOTIFICATION = $826B; + GL_MAX_DEBUG_GROUP_STACK_DEPTH = $826C; + GL_DEBUG_GROUP_STACK_DEPTH = $826D; + GL_BUFFER = $82E0; + GL_SHADER = $82E1; + GL_PROGRAM = $82E2; + GL_QUERY = $82E3; + GL_PROGRAM_PIPELINE = $82E4; + GL_SAMPLER = $82E6; + GL_DISPLAY_LIST = $82E7; + GL_MAX_LABEL_LENGTH = $82E8; + GL_MAX_DEBUG_MESSAGE_LENGTH = $9143; + GL_MAX_DEBUG_LOGGED_MESSAGES = $9144; + GL_DEBUG_LOGGED_MESSAGES = $9145; + GL_DEBUG_SEVERITY_HIGH = $9146; + GL_DEBUG_SEVERITY_MEDIUM = $9147; + GL_DEBUG_SEVERITY_LOW = $9148; + GL_DEBUG_OUTPUT = $92E0; + GL_CONTEXT_FLAG_DEBUG_BIT = $00000002; + GL_COMPUTE_SHADER = $91B9; + GL_MAX_COMPUTE_UNIFORM_BLOCKS = $91BB; + GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC; + GL_MAX_COMPUTE_IMAGE_UNIFORMS = $91BD; + GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262; + GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263; + GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264; + GL_MAX_COMPUTE_ATOMIC_COUNTERS = $8265; + GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266; + GL_MAX_COMPUTE_LOCAL_INVOCATIONS = $90EB; + GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE; + GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF; + GL_COMPUTE_LOCAL_WORK_SIZE = $8267; + GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = $90EC; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = $90ED; + GL_DISPATCH_INDIRECT_BUFFER = $90EE; + GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF; + GL_COMPUTE_SHADER_BIT = $00000020; + GL_COMPRESSED_RGB8_ETC2 = $9274; + GL_COMPRESSED_SRGB8_ETC2 = $9275; + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276; + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277; + GL_COMPRESSED_RGBA8_ETC2_EAC = $9278; + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279; + GL_COMPRESSED_R11_EAC = $9270; + GL_COMPRESSED_SIGNED_R11_EAC = $9271; + GL_COMPRESSED_RG11_EAC = $9272; + GL_COMPRESSED_SIGNED_RG11_EAC = $9273; + GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69; + GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A; + GL_MAX_ELEMENT_INDEX = $8D6B; + GL_MAX_UNIFORM_LOCATIONS = $826E; + GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310; + GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311; + GL_FRAMEBUFFER_DEFAULT_LAYERS = $9312; + GL_FRAMEBUFFER_DEFAULT_SAMPLES = $9313; + GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314; + GL_MAX_FRAMEBUFFER_WIDTH = $9315; + GL_MAX_FRAMEBUFFER_HEIGHT = $9316; + GL_MAX_FRAMEBUFFER_LAYERS = $9317; + GL_MAX_FRAMEBUFFER_SAMPLES = $9318; + GL_INTERNALFORMAT_SUPPORTED = $826F; + GL_INTERNALFORMAT_PREFERRED = $8270; + GL_INTERNALFORMAT_RED_SIZE = $8271; + GL_INTERNALFORMAT_GREEN_SIZE = $8272; + GL_INTERNALFORMAT_BLUE_SIZE = $8273; + GL_INTERNALFORMAT_ALPHA_SIZE = $8274; + GL_INTERNALFORMAT_DEPTH_SIZE = $8275; + GL_INTERNALFORMAT_STENCIL_SIZE = $8276; + GL_INTERNALFORMAT_SHARED_SIZE = $8277; + GL_INTERNALFORMAT_RED_TYPE = $8278; + GL_INTERNALFORMAT_GREEN_TYPE = $8279; + GL_INTERNALFORMAT_BLUE_TYPE = $827A; + GL_INTERNALFORMAT_ALPHA_TYPE = $827B; + GL_INTERNALFORMAT_DEPTH_TYPE = $827C; + GL_INTERNALFORMAT_STENCIL_TYPE = $827D; + GL_MAX_WIDTH = $827E; + GL_MAX_HEIGHT = $827F; + GL_MAX_DEPTH = $8280; + GL_MAX_LAYERS = $8281; + GL_MAX_COMBINED_DIMENSIONS = $8282; + GL_COLOR_COMPONENTS = $8283; + GL_DEPTH_COMPONENTS = $8284; + GL_STENCIL_COMPONENTS = $8285; + GL_COLOR_RENDERABLE = $8286; + GL_DEPTH_RENDERABLE = $8287; + GL_STENCIL_RENDERABLE = $8288; + GL_FRAMEBUFFER_RENDERABLE = $8289; + GL_FRAMEBUFFER_RENDERABLE_LAYERED = $828A; + GL_FRAMEBUFFER_BLEND = $828B; + GL_READ_PIXELS = $828C; + GL_READ_PIXELS_FORMAT = $828D; + GL_READ_PIXELS_TYPE = $828E; + GL_TEXTURE_IMAGE_FORMAT = $828F; + GL_TEXTURE_IMAGE_TYPE = $8290; + GL_GET_TEXTURE_IMAGE_FORMAT = $8291; + GL_GET_TEXTURE_IMAGE_TYPE = $8292; + GL_MIPMAP = $8293; + GL_MANUAL_GENERATE_MIPMAP = $8294; + GL_AUTO_GENERATE_MIPMAP = $8295; + GL_COLOR_ENCODING = $8296; + GL_SRGB_READ = $8297; + GL_SRGB_WRITE = $8298; + GL_SRGB_DECODE_ARB = $8299; + GL_FILTER = $829A; + GL_VERTEX_TEXTURE = $829B; + GL_TESS_CONTROL_TEXTURE = $829C; + GL_TESS_EVALUATION_TEXTURE = $829D; + GL_GEOMETRY_TEXTURE = $829E; + GL_FRAGMENT_TEXTURE = $829F; + GL_COMPUTE_TEXTURE = $82A0; + GL_TEXTURE_SHADOW = $82A1; + GL_TEXTURE_GATHER = $82A2; + GL_TEXTURE_GATHER_SHADOW = $82A3; + GL_SHADER_IMAGE_LOAD = $82A4; + GL_SHADER_IMAGE_STORE = $82A5; + GL_SHADER_IMAGE_ATOMIC = $82A6; + GL_IMAGE_TEXEL_SIZE = $82A7; + GL_IMAGE_COMPATIBILITY_CLASS = $82A8; + GL_IMAGE_PIXEL_FORMAT = $82A9; + GL_IMAGE_PIXEL_TYPE = $82AA; + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = $82AC; + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = $82AD; + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = $82AE; + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = $82AF; + GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = $82B1; + GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = $82B2; + GL_TEXTURE_COMPRESSED_BLOCK_SIZE = $82B3; + GL_CLEAR_BUFFER = $82B4; + GL_TEXTURE_VIEW = $82B5; + GL_VIEW_COMPATIBILITY_CLASS = $82B6; + GL_FULL_SUPPORT = $82B7; + GL_CAVEAT_SUPPORT = $82B8; + GL_IMAGE_CLASS_4_X_32 = $82B9; + GL_IMAGE_CLASS_2_X_32 = $82BA; + GL_IMAGE_CLASS_1_X_32 = $82BB; + GL_IMAGE_CLASS_4_X_16 = $82BC; + GL_IMAGE_CLASS_2_X_16 = $82BD; + GL_IMAGE_CLASS_1_X_16 = $82BE; + GL_IMAGE_CLASS_4_X_8 = $82BF; + GL_IMAGE_CLASS_2_X_8 = $82C0; + GL_IMAGE_CLASS_1_X_8 = $82C1; + GL_IMAGE_CLASS_11_11_10 = $82C2; + GL_IMAGE_CLASS_10_10_10_2 = $82C3; + GL_VIEW_CLASS_128_BITS = $82C4; + GL_VIEW_CLASS_96_BITS = $82C5; + GL_VIEW_CLASS_64_BITS = $82C6; + GL_VIEW_CLASS_48_BITS = $82C7; + GL_VIEW_CLASS_32_BITS = $82C8; + GL_VIEW_CLASS_24_BITS = $82C9; + GL_VIEW_CLASS_16_BITS = $82CA; + GL_VIEW_CLASS_8_BITS = $82CB; + GL_VIEW_CLASS_S3TC_DXT1_RGB = $82CC; + GL_VIEW_CLASS_S3TC_DXT1_RGBA = $82CD; + GL_VIEW_CLASS_S3TC_DXT3_RGBA = $82CE; + GL_VIEW_CLASS_S3TC_DXT5_RGBA = $82CF; + GL_VIEW_CLASS_RGTC1_RED = $82D0; + GL_VIEW_CLASS_RGTC2_RG = $82D1; + GL_VIEW_CLASS_BPTC_UNORM = $82D2; + GL_VIEW_CLASS_BPTC_FLOAT = $82D3; + GL_UNIFORM = $92E1; + GL_UNIFORM_BLOCK = $92E2; + GL_PROGRAM_INPUT = $92E3; + GL_PROGRAM_OUTPUT = $92E4; + GL_BUFFER_VARIABLE = $92E5; + GL_SHADER_STORAGE_BLOCK = $92E6; + GL_VERTEX_SUBROUTINE = $92E8; + GL_TESS_CONTROL_SUBROUTINE = $92E9; + GL_TESS_EVALUATION_SUBROUTINE = $92EA; + GL_GEOMETRY_SUBROUTINE = $92EB; + GL_FRAGMENT_SUBROUTINE = $92EC; + GL_COMPUTE_SUBROUTINE = $92ED; + GL_VERTEX_SUBROUTINE_UNIFORM = $92EE; + GL_TESS_CONTROL_SUBROUTINE_UNIFORM = $92EF; + GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = $92F0; + GL_GEOMETRY_SUBROUTINE_UNIFORM = $92F1; + GL_FRAGMENT_SUBROUTINE_UNIFORM = $92F2; + GL_COMPUTE_SUBROUTINE_UNIFORM = $92F3; + GL_TRANSFORM_FEEDBACK_VARYING = $92F4; + GL_ACTIVE_RESOURCES = $92F5; + GL_MAX_NAME_LENGTH = $92F6; + GL_MAX_NUM_ACTIVE_VARIABLES = $92F7; + GL_MAX_NUM_COMPATIBLE_SUBROUTINES = $92F8; + GL_NAME_LENGTH = $92F9; + GL_TYPE = $92FA; + GL_ARRAY_SIZE = $92FB; + GL_OFFSET = $92FC; + GL_BLOCK_INDEX = $92FD; + GL_ARRAY_STRIDE = $92FE; + GL_MATRIX_STRIDE = $92FF; + GL_IS_ROW_MAJOR = $9300; + GL_ATOMIC_COUNTER_BUFFER_INDEX = $9301; + GL_BUFFER_BINDING = $9302; + GL_BUFFER_DATA_SIZE = $9303; + GL_NUM_ACTIVE_VARIABLES = $9304; + GL_ACTIVE_VARIABLES = $9305; + GL_REFERENCED_BY_VERTEX_SHADER = $9306; + GL_REFERENCED_BY_TESS_CONTROL_SHADER = $9307; + GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308; + GL_REFERENCED_BY_GEOMETRY_SHADER = $9309; + GL_REFERENCED_BY_FRAGMENT_SHADER = $930A; + GL_REFERENCED_BY_COMPUTE_SHADER = $930B; + GL_TOP_LEVEL_ARRAY_SIZE = $930C; + GL_TOP_LEVEL_ARRAY_STRIDE = $930D; + GL_LOCATION = $930E; + GL_LOCATION_INDEX = $930F; + GL_IS_PER_PATCH = $92E7; + GL_SHADER_STORAGE_BUFFER = $90D2; + GL_SHADER_STORAGE_BUFFER_BINDING = $90D3; + GL_SHADER_STORAGE_BUFFER_START = $90D4; + GL_SHADER_STORAGE_BUFFER_SIZE = $90D5; + GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6; + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7; + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8; + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9; + GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA; + GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB; + GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC; + GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD; + GL_MAX_SHADER_STORAGE_BLOCK_SIZE = $90DE; + GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF; + GL_SHADER_STORAGE_BARRIER_BIT = $2000; + GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS; + GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA; + + GL_TEXTURE_BUFFER_OFFSET = $919D; + GL_TEXTURE_BUFFER_SIZE = $919E; + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F; + GL_TEXTURE_VIEW_MIN_LEVEL = $82DB; + GL_TEXTURE_VIEW_NUM_LEVELS = $82DC; + GL_TEXTURE_VIEW_MIN_LAYER = $82DD; + GL_TEXTURE_VIEW_NUM_LAYERS = $82DE; + GL_TEXTURE_IMMUTABLE_LEVELS = $82DF; + GL_VERTEX_ATTRIB_BINDING = $82D4; + GL_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D5; + GL_VERTEX_BINDING_DIVISOR = $82D6; + GL_VERTEX_BINDING_OFFSET = $82D7; + GL_VERTEX_BINDING_STRIDE = $82D8; + GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9; + GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA; + + // GL 4.4 + GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5; + GL_MAP_PERSISTENT_BIT = $0040; + GL_MAP_COHERENT_BIT = $0080; + GL_DYNAMIC_STORAGE_BIT = $0100; + GL_CLIENT_STORAGE_BIT = $0200; + GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = $00004000; + GL_BUFFER_IMMUTABLE_STORAGE = $821F; + GL_BUFFER_STORAGE_FLAGS = $8220; + GL_CLEAR_TEXTURE = $9365; + GL_LOCATION_COMPONENT = $934A; + GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = $934B; + GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = $934C; + GL_QUERY_BUFFER = $9192; + GL_QUERY_BUFFER_BARRIER_BIT = $00008000; + GL_QUERY_BUFFER_BINDING = $9193; + GL_QUERY_RESULT_NO_WAIT = $9194; + GL_MIRROR_CLAMP_TO_EDGE = $8743; + // GL 4.5 + GL_CONTEXT_LOST = $0507; + GL_NEGATIVE_ONE_TO_ONE = $935E; + GL_ZERO_TO_ONE = $935F; + GL_CLIP_ORIGIN = $935C; + GL_CLIP_DEPTH_MODE = $935D; + GL_QUERY_WAIT_INVERTED = $8E17; + GL_QUERY_NO_WAIT_INVERTED = $8E18; + GL_QUERY_BY_REGION_WAIT_INVERTED = $8E19; + GL_QUERY_BY_REGION_NO_WAIT_INVERTED = $8E1A; + GL_MAX_CULL_DISTANCES = $82F9; + GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = $82FA; + GL_TEXTURE_TARGET = $1006; + GL_QUERY_TARGET = $82EA; + GL_TEXTURE_BINDING = $82EB; + GL_GUILTY_CONTEXT_RESET = $8253; + GL_INNOCENT_CONTEXT_RESET = $8254; + GL_UNKNOWN_CONTEXT_RESET = $8255; + GL_RESET_NOTIFICATION_STRATEGY = $8256; + GL_LOSE_CONTEXT_ON_RESET = $8252; + GL_NO_RESET_NOTIFICATION = $8261; + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = $00000004; + GL_CONTEXT_RELEASE_BEHAVIOR = $82FB; + GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = $82FC; + // GL_ATI_draw_buffers + GL_MAX_DRAW_BUFFERS_ATI = $8824; + GL_DRAW_BUFFER0_ATI = $8825; + GL_DRAW_BUFFER1_ATI = $8826; + GL_DRAW_BUFFER2_ATI = $8827; + GL_DRAW_BUFFER3_ATI = $8828; + GL_DRAW_BUFFER4_ATI = $8829; + GL_DRAW_BUFFER5_ATI = $882A; + GL_DRAW_BUFFER6_ATI = $882B; + GL_DRAW_BUFFER7_ATI = $882C; + GL_DRAW_BUFFER8_ATI = $882D; + GL_DRAW_BUFFER9_ATI = $882E; + GL_DRAW_BUFFER10_ATI = $882F; + GL_DRAW_BUFFER11_ATI = $8830; + GL_DRAW_BUFFER12_ATI = $8831; + GL_DRAW_BUFFER13_ATI = $8832; + GL_DRAW_BUFFER14_ATI = $8833; + GL_DRAW_BUFFER15_ATI = $8834; + // GL_ATI_element_array + GL_ELEMENT_ARRAY_ATI = $8768; + GL_ELEMENT_ARRAY_TYPE_ATI = $8769; + GL_ELEMENT_ARRAY_POINTER_ATI = $876A; + // GL_ATI_envmap_bumpmap + GL_BUMP_ROT_MATRIX_ATI = $8775; + GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776; + GL_BUMP_NUM_TEX_UNITS_ATI = $8777; + GL_BUMP_TEX_UNITS_ATI = $8778; + GL_DUDV_ATI = $8779; + GL_DU8DV8_ATI = $877A; + GL_BUMP_ENVMAP_ATI = $877B; + GL_BUMP_TARGET_ATI = $877C; + // GL_ATI_fragment_shader + GL_FRAGMENT_SHADER_ATI = $8920; + GL_REG_0_ATI = $8921; + GL_REG_1_ATI = $8922; + GL_REG_2_ATI = $8923; + GL_REG_3_ATI = $8924; + GL_REG_4_ATI = $8925; + GL_REG_5_ATI = $8926; + GL_REG_6_ATI = $8927; + GL_REG_7_ATI = $8928; + GL_REG_8_ATI = $8929; + GL_REG_9_ATI = $892A; + GL_REG_10_ATI = $892B; + GL_REG_11_ATI = $892C; + GL_REG_12_ATI = $892D; + GL_REG_13_ATI = $892E; + GL_REG_14_ATI = $892F; + GL_REG_15_ATI = $8930; + GL_REG_16_ATI = $8931; + GL_REG_17_ATI = $8932; + GL_REG_18_ATI = $8933; + GL_REG_19_ATI = $8934; + GL_REG_20_ATI = $8935; + GL_REG_21_ATI = $8936; + GL_REG_22_ATI = $8937; + GL_REG_23_ATI = $8938; + GL_REG_24_ATI = $8939; + GL_REG_25_ATI = $893A; + GL_REG_26_ATI = $893B; + GL_REG_27_ATI = $893C; + GL_REG_28_ATI = $893D; + GL_REG_29_ATI = $893E; + GL_REG_30_ATI = $893F; + GL_REG_31_ATI = $8940; + GL_CON_0_ATI = $8941; + GL_CON_1_ATI = $8942; + GL_CON_2_ATI = $8943; + GL_CON_3_ATI = $8944; + GL_CON_4_ATI = $8945; + GL_CON_5_ATI = $8946; + GL_CON_6_ATI = $8947; + GL_CON_7_ATI = $8948; + GL_CON_8_ATI = $8949; + GL_CON_9_ATI = $894A; + GL_CON_10_ATI = $894B; + GL_CON_11_ATI = $894C; + GL_CON_12_ATI = $894D; + GL_CON_13_ATI = $894E; + GL_CON_14_ATI = $894F; + GL_CON_15_ATI = $8950; + GL_CON_16_ATI = $8951; + GL_CON_17_ATI = $8952; + GL_CON_18_ATI = $8953; + GL_CON_19_ATI = $8954; + GL_CON_20_ATI = $8955; + GL_CON_21_ATI = $8956; + GL_CON_22_ATI = $8957; + GL_CON_23_ATI = $8958; + GL_CON_24_ATI = $8959; + GL_CON_25_ATI = $895A; + GL_CON_26_ATI = $895B; + GL_CON_27_ATI = $895C; + GL_CON_28_ATI = $895D; + GL_CON_29_ATI = $895E; + GL_CON_30_ATI = $895F; + GL_CON_31_ATI = $8960; + GL_MOV_ATI = $8961; + GL_ADD_ATI = $8963; + GL_MUL_ATI = $8964; + GL_SUB_ATI = $8965; + GL_DOT3_ATI = $8966; + GL_DOT4_ATI = $8967; + GL_MAD_ATI = $8968; + GL_LERP_ATI = $8969; + GL_CND_ATI = $896A; + GL_CND0_ATI = $896B; + GL_DOT2_ADD_ATI = $896C; + GL_SECONDARY_INTERPOLATOR_ATI = $896D; + GL_NUM_FRAGMENT_REGISTERS_ATI = $896E; + GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F; + GL_NUM_PASSES_ATI = $8970; + GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971; + GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972; + GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973; + GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974; + GL_COLOR_ALPHA_PAIRING_ATI = $8975; + GL_SWIZZLE_STR_ATI = $8976; + GL_SWIZZLE_STQ_ATI = $8977; + GL_SWIZZLE_STR_DR_ATI = $8978; + GL_SWIZZLE_STQ_DQ_ATI = $8979; + GL_SWIZZLE_STRQ_ATI = $897A; + GL_SWIZZLE_STRQ_DQ_ATI = $897B; + GL_RED_BIT_ATI = $00000001; + GL_GREEN_BIT_ATI = $00000002; + GL_BLUE_BIT_ATI = $00000004; + GL_2X_BIT_ATI = $00000001; + GL_4X_BIT_ATI = $00000002; + GL_8X_BIT_ATI = $00000004; + GL_HALF_BIT_ATI = $00000008; + GL_QUARTER_BIT_ATI = $00000010; + GL_EIGHTH_BIT_ATI = $00000020; + GL_SATURATE_BIT_ATI = $00000040; + GL_COMP_BIT_ATI = $00000002; + GL_NEGATE_BIT_ATI = $00000004; + GL_BIAS_BIT_ATI = $00000008; + // GL_ATI_pn_triangles + GL_PN_TRIANGLES_ATI = $87F0; + GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1; + GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2; + GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3; + GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4; + GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5; + GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6; + GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7; + GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8; + // GL_ATI_separate_stencil + GL_STENCIL_BACK_FUNC_ATI = $8800; + GL_STENCIL_BACK_FAIL_ATI = $8801; + GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802; + GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803; + // GL_ATI_text_fragment_shader + GL_TEXT_FRAGMENT_SHADER_ATI = $8200; + // GL_ATI_texture_env_combine3 + GL_MODULATE_ADD_ATI = $8744; + GL_MODULATE_SIGNED_ADD_ATI = $8745; + GL_MODULATE_SUBTRACT_ATI = $8746; + // GL_ATI_texture_float + GL_RGBA_FLOAT32_ATI = $8814; + GL_RGB_FLOAT32_ATI = $8815; + GL_ALPHA_FLOAT32_ATI = $8816; + GL_INTENSITY_FLOAT32_ATI = $8817; + GL_LUMINANCE_FLOAT32_ATI = $8818; + GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819; + GL_RGBA_FLOAT16_ATI = $881A; + GL_RGB_FLOAT16_ATI = $881B; + GL_ALPHA_FLOAT16_ATI = $881C; + GL_INTENSITY_FLOAT16_ATI = $881D; + GL_LUMINANCE_FLOAT16_ATI = $881E; + GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F; + // GL_ATI_texture_mirror_once + GL_MIRROR_CLAMP_ATI = $8742; + GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743; + // GL_ATI_vertex_array_object + GL_STATIC_ATI = $8760; + GL_DYNAMIC_ATI = $8761; + GL_PRESERVE_ATI = $8762; + GL_DISCARD_ATI = $8763; + GL_OBJECT_BUFFER_SIZE_ATI = $8764; + GL_OBJECT_BUFFER_USAGE_ATI = $8765; + GL_ARRAY_OBJECT_BUFFER_ATI = $8766; + GL_ARRAY_OBJECT_OFFSET_ATI = $8767; + // GL_ATI_vertex_streams + GL_MAX_VERTEX_STREAMS_ATI = $876B; + GL_VERTEX_STREAM0_ATI = $876C; + GL_VERTEX_STREAM1_ATI = $876D; + GL_VERTEX_STREAM2_ATI = $876E; + GL_VERTEX_STREAM3_ATI = $876F; + GL_VERTEX_STREAM4_ATI = $8770; + GL_VERTEX_STREAM5_ATI = $8771; + GL_VERTEX_STREAM6_ATI = $8772; + GL_VERTEX_STREAM7_ATI = $8773; + GL_VERTEX_SOURCE_ATI = $8774; + // GL_ATI_meminfo + GL_VBO_FREE_MEMORY_ATI = $87FB; + GL_TEXTURE_FREE_MEMORY_ATI = $87FC; + GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD; + // GL_AMD_performance_monitor + GL_COUNTER_TYPE_AMD = $8BC0; + GL_COUNTER_RANGE_AMD = $8BC1; + GL_UNSIGNED_INT64_AMD = $8BC2; + GL_PERCENTAGE_AMD = $8BC3; + GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4; + GL_PERFMON_RESULT_SIZE_AMD = $8BC5; + GL_PERFMON_RESULT_AMD = $8BC6; + // GL_AMD_vertex_shader_tesselator + GL_SAMPLER_BUFFER_AMD = $9001; + GL_INT_SAMPLER_BUFFER_AMD = $9002; + GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003; + GL_TESSELLATION_MODE_AMD = $9004; + GL_TESSELLATION_FACTOR_AMD = $9005; + GL_DISCRETE_AMD = $9006; + GL_CONTINUOUS_AMD = $9007; + // GL_AMD_name_gen_delete + GL_DATA_BUFFER_AMD = $9151; + GL_PERFORMANCE_MONITOR_AMD = $9152; + GL_QUERY_OBJECT_AMD = $9153; + GL_VERTEX_ARRAY_OBJECT_AMD = $9154; + GL_SAMPLER_OBJECT_AMD = $9155; + // GL_AMD_debug_output + GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = $9144; + GL_DEBUG_LOGGED_MESSAGES_AMD = $9145; + GL_DEBUG_SEVERITY_HIGH_AMD = $9146; + GL_DEBUG_SEVERITY_MEDIUM_AMD = $9147; + GL_DEBUG_SEVERITY_LOW_AMD = $9148; + GL_DEBUG_CATEGORY_API_ERROR_AMD = $9149; + GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = $914A; + GL_DEBUG_CATEGORY_DEPRECATION_AMD = $914B; + GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = $914C; + GL_DEBUG_CATEGORY_PERFORMANCE_AMD = $914D; + GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = $914E; + GL_DEBUG_CATEGORY_APPLICATION_AMD = $914F; + GL_DEBUG_CATEGORY_OTHER_AMD = $9150; + // GL_AMD_depth_clamp_separate + GL_DEPTH_CLAMP_NEAR_AMD = $901E; + GL_DEPTH_CLAMP_FAR_AMD = $901F; + // GL_EXT_422_pixels + GL_422_EXT = $80CC; + GL_422_REV_EXT = $80CD; + GL_422_AVERAGE_EXT = $80CE; + GL_422_REV_AVERAGE_EXT = $80CF; + // GL_EXT_abgr + GL_ABGR_EXT = $8000; + // GL_EXT_bgra + GL_BGR_EXT = $80E0; + GL_BGRA_EXT = $80E1; + // GL_EXT_blend_color + GL_CONSTANT_COLOR_EXT = $8001; + GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002; + GL_CONSTANT_ALPHA_EXT = $8003; + GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004; + GL_BLEND_COLOR_EXT = $8005; + // GL_EXT_blend_func_separate + GL_BLEND_DST_RGB_EXT = $80C8; + GL_BLEND_SRC_RGB_EXT = $80C9; + GL_BLEND_DST_ALPHA_EXT = $80CA; + GL_BLEND_SRC_ALPHA_EXT = $80CB; + // GL_EXT_blend_minmax + GL_FUNC_ADD_EXT = $8006; + GL_MIN_EXT = $8007; + GL_MAX_EXT = $8008; + GL_BLEND_EQUATION_EXT = $8009; + // GL_EXT_blend_subtract + GL_FUNC_SUBTRACT_EXT = $800A; + GL_FUNC_REVERSE_SUBTRACT_EXT = $800B; + // GL_EXT_clip_volume_hint + GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0; + // GL_EXT_cmyka + GL_CMYK_EXT = $800C; + GL_CMYKA_EXT = $800D; + GL_PACK_CMYK_HINT_EXT = $800E; + GL_UNPACK_CMYK_HINT_EXT = $800F; + // GL_EXT_compiled_vertex_array + GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8; + GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9; + // GL_EXT_convolution + GL_CONVOLUTION_1D_EXT = $8010; + GL_CONVOLUTION_2D_EXT = $8011; + GL_SEPARABLE_2D_EXT = $8012; + GL_CONVOLUTION_BORDER_MODE_EXT = $8013; + GL_CONVOLUTION_FILTER_SCALE_EXT = $8014; + GL_CONVOLUTION_FILTER_BIAS_EXT = $8015; + GL_REDUCE_EXT = $8016; + GL_CONVOLUTION_FORMAT_EXT = $8017; + GL_CONVOLUTION_WIDTH_EXT = $8018; + GL_CONVOLUTION_HEIGHT_EXT = $8019; + GL_MAX_CONVOLUTION_WIDTH_EXT = $801A; + GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B; + GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C; + GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D; + GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E; + GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F; + GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020; + GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021; + GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022; + GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023; + // GL_EXT_coordinate_frame + GL_TANGENT_ARRAY_EXT = $8439; + GL_BINORMAL_ARRAY_EXT = $843A; + GL_CURRENT_TANGENT_EXT = $843B; + GL_CURRENT_BINORMAL_EXT = $843C; + GL_TANGENT_ARRAY_TYPE_EXT = $843E; + GL_TANGENT_ARRAY_STRIDE_EXT = $843F; + GL_BINORMAL_ARRAY_TYPE_EXT = $8440; + GL_BINORMAL_ARRAY_STRIDE_EXT = $8441; + GL_TANGENT_ARRAY_POINTER_EXT = $8442; + GL_BINORMAL_ARRAY_POINTER_EXT = $8443; + GL_MAP1_TANGENT_EXT = $8444; + GL_MAP2_TANGENT_EXT = $8445; + GL_MAP1_BINORMAL_EXT = $8446; + GL_MAP2_BINORMAL_EXT = $8447; + // GL_EXT_cull_vertex + GL_CULL_VERTEX_EXT = $81AA; + GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB; + GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC; + // GL_EXT_draw_range_elements + GL_MAX_ELEMENTS_VERTICES_EXT = $80E8; + GL_MAX_ELEMENTS_INDICES_EXT = $80E9; + // GL_EXT_fog_coord + GL_FOG_COORDINATE_SOURCE_EXT = $8450; + GL_FOG_COORDINATE_EXT = $8451; + GL_FRAGMENT_DEPTH_EXT = $8452; + GL_CURRENT_FOG_COORDINATE_EXT = $8453; + GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454; + GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455; + GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456; + GL_FOG_COORDINATE_ARRAY_EXT = $8457; + // GL_EXT_framebuffer_object + GL_FRAMEBUFFER_EXT = $8D40; + GL_RENDERBUFFER_EXT = $8D41; + GL_STENCIL_INDEX_EXT = $8D45; + GL_STENCIL_INDEX1_EXT = $8D46; + GL_STENCIL_INDEX4_EXT = $8D47; + GL_STENCIL_INDEX8_EXT = $8D48; + GL_STENCIL_INDEX16_EXT = $8D49; + GL_RENDERBUFFER_WIDTH_EXT = $8D42; + GL_RENDERBUFFER_HEIGHT_EXT = $8D43; + GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4; + GL_COLOR_ATTACHMENT0_EXT = $8CE0; + GL_COLOR_ATTACHMENT1_EXT = $8CE1; + GL_COLOR_ATTACHMENT2_EXT = $8CE2; + GL_COLOR_ATTACHMENT3_EXT = $8CE3; + GL_COLOR_ATTACHMENT4_EXT = $8CE4; + GL_COLOR_ATTACHMENT5_EXT = $8CE5; + GL_COLOR_ATTACHMENT6_EXT = $8CE6; + GL_COLOR_ATTACHMENT7_EXT = $8CE7; + GL_COLOR_ATTACHMENT8_EXT = $8CE8; + GL_COLOR_ATTACHMENT9_EXT = $8CE9; + GL_COLOR_ATTACHMENT10_EXT = $8CEA; + GL_COLOR_ATTACHMENT11_EXT = $8CEB; + GL_COLOR_ATTACHMENT12_EXT = $8CEC; + GL_COLOR_ATTACHMENT13_EXT = $8CED; + GL_COLOR_ATTACHMENT14_EXT = $8CEE; + GL_COLOR_ATTACHMENT15_EXT = $8CEF; + GL_DEPTH_ATTACHMENT_EXT = $8D00; + GL_STENCIL_ATTACHMENT_EXT = $8D20; + GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5; + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6; + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7; + GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8; + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9; + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA; + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB; + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC; + GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD; + GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE; + GL_FRAMEBUFFER_BINDING_EXT = $8CA6; + GL_RENDERBUFFER_BINDING_EXT = $8CA7; + GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF; + GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8; + GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506; + // GL_EXT_histogram + GL_HISTOGRAM_EXT = $8024; + GL_PROXY_HISTOGRAM_EXT = $8025; + GL_HISTOGRAM_WIDTH_EXT = $8026; + GL_HISTOGRAM_FORMAT_EXT = $8027; + GL_HISTOGRAM_RED_SIZE_EXT = $8028; + GL_HISTOGRAM_GREEN_SIZE_EXT = $8029; + GL_HISTOGRAM_BLUE_SIZE_EXT = $802A; + GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B; + GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C; + GL_HISTOGRAM_SINK_EXT = $802D; + GL_MINMAX_EXT = $802E; + GL_MINMAX_FORMAT_EXT = $802F; + GL_MINMAX_SINK_EXT = $8030; + GL_TABLE_TOO_LARGE_EXT = $8031; + // GL_EXT_index_array_formats + GL_IUI_V2F_EXT = $81AD; + GL_IUI_V3F_EXT = $81AE; + GL_IUI_N3F_V2F_EXT = $81AF; + GL_IUI_N3F_V3F_EXT = $81B0; + GL_T2F_IUI_V2F_EXT = $81B1; + GL_T2F_IUI_V3F_EXT = $81B2; + GL_T2F_IUI_N3F_V2F_EXT = $81B3; + GL_T2F_IUI_N3F_V3F_EXT = $81B4; + // GL_EXT_index_func + GL_INDEX_TEST_EXT = $81B5; + GL_INDEX_TEST_FUNC_EXT = $81B6; + GL_INDEX_TEST_REF_EXT = $81B7; + // GL_EXT_index_material + GL_INDEX_MATERIAL_EXT = $81B8; + GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9; + GL_INDEX_MATERIAL_FACE_EXT = $81BA; + // GL_EXT_light_texture + GL_FRAGMENT_MATERIAL_EXT = $8349; + GL_FRAGMENT_NORMAL_EXT = $834A; + GL_FRAGMENT_COLOR_EXT = $834C; + GL_ATTENUATION_EXT = $834D; + GL_SHADOW_ATTENUATION_EXT = $834E; + GL_TEXTURE_APPLICATION_MODE_EXT = $834F; + GL_TEXTURE_LIGHT_EXT = $8350; + GL_TEXTURE_MATERIAL_FACE_EXT = $8351; + GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352; + // GL_EXT_multisample + GL_MULTISAMPLE_EXT = $809D; + GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E; + GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F; + GL_SAMPLE_MASK_EXT = $80A0; + GL_1PASS_EXT = $80A1; + GL_2PASS_0_EXT = $80A2; + GL_2PASS_1_EXT = $80A3; + GL_4PASS_0_EXT = $80A4; + GL_4PASS_1_EXT = $80A5; + GL_4PASS_2_EXT = $80A6; + GL_4PASS_3_EXT = $80A7; + GL_SAMPLE_BUFFERS_EXT = $80A8; + GL_SAMPLES_EXT = $80A9; + GL_SAMPLE_MASK_VALUE_EXT = $80AA; + GL_SAMPLE_MASK_INVERT_EXT = $80AB; + GL_SAMPLE_PATTERN_EXT = $80AC; + GL_MULTISAMPLE_BIT_EXT = $20000000; + // GL_EXT_packed_pixels + GL_UNSIGNED_BYTE_3_3_2_EXT = $8032; + GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033; + GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034; + GL_UNSIGNED_INT_8_8_8_8_EXT = $8035; + GL_UNSIGNED_INT_10_10_10_2_EXT = $8036; + // GL_EXT_paletted_texture + GL_COLOR_INDEX1_EXT = $80E2; + GL_COLOR_INDEX2_EXT = $80E3; + GL_COLOR_INDEX4_EXT = $80E4; + GL_COLOR_INDEX8_EXT = $80E5; + GL_COLOR_INDEX12_EXT = $80E6; + GL_COLOR_INDEX16_EXT = $80E7; + GL_TEXTURE_INDEX_SIZE_EXT = $80ED; + // GL_EXT_pixel_transform + GL_PIXEL_TRANSFORM_2D_EXT = $8330; + GL_PIXEL_MAG_FILTER_EXT = $8331; + GL_PIXEL_MIN_FILTER_EXT = $8332; + GL_PIXEL_CUBIC_WEIGHT_EXT = $8333; + GL_CUBIC_EXT = $8334; + GL_AVERAGE_EXT = $8335; + GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336; + GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337; + GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338; + // GL_EXT_point_parameters + GL_POINT_SIZE_MIN_EXT = $8126; + GL_POINT_SIZE_MAX_EXT = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128; + GL_DISTANCE_ATTENUATION_EXT = $8129; + // GL_EXT_polygon_offset + GL_POLYGON_OFFSET_EXT = $8037; + GL_POLYGON_OFFSET_FACTOR_EXT = $8038; + GL_POLYGON_OFFSET_BIAS_EXT = $8039; + // GL_EXT_rescale_normal + GL_RESCALE_NORMAL_EXT = $803A; + // GL_EXT_secondary_color + GL_COLOR_SUM_EXT = $8458; + GL_CURRENT_SECONDARY_COLOR_EXT = $8459; + GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A; + GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B; + GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C; + GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D; + GL_SECONDARY_COLOR_ARRAY_EXT = $845E; + // GL_EXT_separate_specular_color + GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8; + GL_SINGLE_COLOR_EXT = $81F9; + GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA; + // GL_EXT_shared_texture_palette + GL_SHARED_TEXTURE_PALETTE_EXT = $81FB; + // GL_EXT_stencil_two_side + GL_STENCIL_TEST_TWO_SIDE_EXT = $8910; + GL_ACTIVE_STENCIL_FACE_EXT = $8911; + // GL_EXT_stencil_wrap + GL_INCR_WRAP_EXT = $8507; + GL_DECR_WRAP_EXT = $8508; + // GL_EXT_texture + GL_ALPHA4_EXT = $803B; + GL_ALPHA8_EXT = $803C; + GL_ALPHA12_EXT = $803D; + GL_ALPHA16_EXT = $803E; + GL_LUMINANCE4_EXT = $803F; + GL_LUMINANCE8_EXT = $8040; + GL_LUMINANCE12_EXT = $8041; + GL_LUMINANCE16_EXT = $8042; + GL_LUMINANCE4_ALPHA4_EXT = $8043; + GL_LUMINANCE6_ALPHA2_EXT = $8044; + GL_LUMINANCE8_ALPHA8_EXT = $8045; + GL_LUMINANCE12_ALPHA4_EXT = $8046; + GL_LUMINANCE12_ALPHA12_EXT = $8047; + GL_LUMINANCE16_ALPHA16_EXT = $8048; + GL_INTENSITY_EXT = $8049; + GL_INTENSITY4_EXT = $804A; + GL_INTENSITY8_EXT = $804B; + GL_INTENSITY12_EXT = $804C; + GL_INTENSITY16_EXT = $804D; + GL_RGB2_EXT = $804E; + GL_RGB4_EXT = $804F; + GL_RGB5_EXT = $8050; + GL_RGB8_EXT = $8051; + GL_RGB10_EXT = $8052; + GL_RGB12_EXT = $8053; + GL_RGB16_EXT = $8054; + GL_RGBA2_EXT = $8055; + GL_RGBA4_EXT = $8056; + GL_RGB5_A1_EXT = $8057; + GL_RGBA8_EXT = $8058; + GL_RGB10_A2_EXT = $8059; + GL_RGBA12_EXT = $805A; + GL_RGBA16_EXT = $805B; + GL_TEXTURE_RED_SIZE_EXT = $805C; + GL_TEXTURE_GREEN_SIZE_EXT = $805D; + GL_TEXTURE_BLUE_SIZE_EXT = $805E; + GL_TEXTURE_ALPHA_SIZE_EXT = $805F; + GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060; + GL_TEXTURE_INTENSITY_SIZE_EXT = $8061; + GL_REPLACE_EXT = $8062; + GL_PROXY_TEXTURE_1D_EXT = $8063; + GL_PROXY_TEXTURE_2D_EXT = $8064; + GL_TEXTURE_TOO_LARGE_EXT = $8065; + // GL_EXT_texture3D + GL_PACK_SKIP_IMAGES_EXT = $806B; + GL_PACK_IMAGE_HEIGHT_EXT = $806C; + GL_UNPACK_SKIP_IMAGES_EXT = $806D; + GL_UNPACK_IMAGE_HEIGHT_EXT = $806E; + GL_TEXTURE_3D_EXT = $806F; + GL_PROXY_TEXTURE_3D_EXT = $8070; + GL_TEXTURE_DEPTH_EXT = $8071; + GL_TEXTURE_WRAP_R_EXT = $8072; + GL_MAX_3D_TEXTURE_SIZE_EXT = $8073; + // GL_EXT_texture_compression_s3tc + GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0; + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1; + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2; + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3; + // GL_EXT_texture_cube_map + GL_NORMAL_MAP_EXT = $8511; + GL_REFLECTION_MAP_EXT = $8512; + GL_TEXTURE_CUBE_MAP_EXT = $8513; + GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514; + GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A; + GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C; + // GL_EXT_texture_edge_clamp + GL_CLAMP_TO_EDGE_EXT = $812F; + // GL_EXT_texture_env_combine + GL_COMBINE_EXT = $8570; + GL_COMBINE_RGB_EXT = $8571; + GL_COMBINE_ALPHA_EXT = $8572; + GL_RGB_SCALE_EXT = $8573; + GL_ADD_SIGNED_EXT = $8574; + GL_INTERPOLATE_EXT = $8575; + GL_CONSTANT_EXT = $8576; + GL_PRIMARY_COLOR_EXT = $8577; + GL_PREVIOUS_EXT = $8578; + GL_SOURCE0_RGB_EXT = $8580; + GL_SOURCE1_RGB_EXT = $8581; + GL_SOURCE2_RGB_EXT = $8582; + GL_SOURCE0_ALPHA_EXT = $8588; + GL_SOURCE1_ALPHA_EXT = $8589; + GL_SOURCE2_ALPHA_EXT = $858A; + GL_OPERAND0_RGB_EXT = $8590; + GL_OPERAND1_RGB_EXT = $8591; + GL_OPERAND2_RGB_EXT = $8592; + GL_OPERAND0_ALPHA_EXT = $8598; + GL_OPERAND1_ALPHA_EXT = $8599; + GL_OPERAND2_ALPHA_EXT = $859A; + // GL_EXT_texture_env_dot3 + GL_DOT3_RGB_EXT = $8740; + GL_DOT3_RGBA_EXT = $8741; + // GL_EXT_texture_filter_anisotropic + GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; + // GL_EXT_texture_lod_bias + GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD; + GL_TEXTURE_FILTER_CONTROL_EXT = $8500; + GL_TEXTURE_LOD_BIAS_EXT = $8501; + // GL_EXT_texture_object + GL_TEXTURE_PRIORITY_EXT = $8066; + GL_TEXTURE_RESIDENT_EXT = $8067; + GL_TEXTURE_1D_BINDING_EXT = $8068; + GL_TEXTURE_2D_BINDING_EXT = $8069; + GL_TEXTURE_3D_BINDING_EXT = $806A; + // GL_EXT_texture_perturb_normal + GL_PERTURB_EXT = $85AE; + GL_TEXTURE_NORMAL_EXT = $85AF; + // GL_EXT_texture_rectangle + GL_TEXTURE_RECTANGLE_EXT = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8; + // GL_EXT_vertex_array + GL_VERTEX_ARRAY_EXT = $8074; + GL_NORMAL_ARRAY_EXT = $8075; + GL_COLOR_ARRAY_EXT = $8076; + GL_INDEX_ARRAY_EXT = $8077; + GL_TEXTURE_COORD_ARRAY_EXT = $8078; + GL_EDGE_FLAG_ARRAY_EXT = $8079; + GL_VERTEX_ARRAY_SIZE_EXT = $807A; + GL_VERTEX_ARRAY_TYPE_EXT = $807B; + GL_VERTEX_ARRAY_STRIDE_EXT = $807C; + GL_VERTEX_ARRAY_COUNT_EXT = $807D; + GL_NORMAL_ARRAY_TYPE_EXT = $807E; + GL_NORMAL_ARRAY_STRIDE_EXT = $807F; + GL_NORMAL_ARRAY_COUNT_EXT = $8080; + GL_COLOR_ARRAY_SIZE_EXT = $8081; + GL_COLOR_ARRAY_TYPE_EXT = $8082; + GL_COLOR_ARRAY_STRIDE_EXT = $8083; + GL_COLOR_ARRAY_COUNT_EXT = $8084; + GL_INDEX_ARRAY_TYPE_EXT = $8085; + GL_INDEX_ARRAY_STRIDE_EXT = $8086; + GL_INDEX_ARRAY_COUNT_EXT = $8087; + GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088; + GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089; + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A; + GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B; + GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C; + GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D; + GL_VERTEX_ARRAY_POINTER_EXT = $808E; + GL_NORMAL_ARRAY_POINTER_EXT = $808F; + GL_COLOR_ARRAY_POINTER_EXT = $8090; + GL_INDEX_ARRAY_POINTER_EXT = $8091; + GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092; + GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093; + // GL_EXT_vertex_shader + GL_VERTEX_SHADER_EXT = $8780; + GL_VERTEX_SHADER_BINDING_EXT = $8781; + GL_OP_INDEX_EXT = $8782; + GL_OP_NEGATE_EXT = $8783; + GL_OP_DOT3_EXT = $8784; + GL_OP_DOT4_EXT = $8785; + GL_OP_MUL_EXT = $8786; + GL_OP_ADD_EXT = $8787; + GL_OP_MADD_EXT = $8788; + GL_OP_FRAC_EXT = $8789; + GL_OP_MAX_EXT = $878A; + GL_OP_MIN_EXT = $878B; + GL_OP_SET_GE_EXT = $878C; + GL_OP_SET_LT_EXT = $878D; + GL_OP_CLAMP_EXT = $878E; + GL_OP_FLOOR_EXT = $878F; + GL_OP_ROUND_EXT = $8790; + GL_OP_EXP_BASE_2_EXT = $8791; + GL_OP_LOG_BASE_2_EXT = $8792; + GL_OP_POWER_EXT = $8793; + GL_OP_RECIP_EXT = $8794; + GL_OP_RECIP_SQRT_EXT = $8795; + GL_OP_SUB_EXT = $8796; + GL_OP_CROSS_PRODUCT_EXT = $8797; + GL_OP_MULTIPLY_MATRIX_EXT = $8798; + GL_OP_MOV_EXT = $8799; + GL_OUTPUT_VERTEX_EXT = $879A; + GL_OUTPUT_COLOR0_EXT = $879B; + GL_OUTPUT_COLOR1_EXT = $879C; + GL_OUTPUT_TEXTURE_COORD0_EXT = $879D; + GL_OUTPUT_TEXTURE_COORD1_EXT = $879E; + GL_OUTPUT_TEXTURE_COORD2_EXT = $879F; + GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0; + GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1; + GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2; + GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3; + GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4; + GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5; + GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6; + GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7; + GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8; + GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9; + GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA; + GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB; + GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC; + GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD; + GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE; + GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF; + GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0; + GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1; + GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2; + GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3; + GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4; + GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5; + GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6; + GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7; + GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8; + GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9; + GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA; + GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB; + GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC; + GL_OUTPUT_FOG_EXT = $87BD; + GL_SCALAR_EXT = $87BE; + GL_VECTOR_EXT = $87BF; + GL_MATRIX_EXT = $87C0; + GL_VARIANT_EXT = $87C1; + GL_INVARIANT_EXT = $87C2; + GL_LOCAL_CONSTANT_EXT = $87C3; + GL_LOCAL_EXT = $87C4; + GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5; + GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6; + GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7; + GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8; + GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9; + GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA; + GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB; + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC; + GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD; + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE; + GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF; + GL_VERTEX_SHADER_VARIANTS_EXT = $87D0; + GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1; + GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2; + GL_VERTEX_SHADER_LOCALS_EXT = $87D3; + GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4; + GL_X_EXT = $87D5; + GL_Y_EXT = $87D6; + GL_Z_EXT = $87D7; + GL_W_EXT = $87D8; + GL_NEGATIVE_X_EXT = $87D9; + GL_NEGATIVE_Y_EXT = $87DA; + GL_NEGATIVE_Z_EXT = $87DB; + GL_NEGATIVE_W_EXT = $87DC; + GL_ZERO_EXT = $87DD; + GL_ONE_EXT = $87DE; + GL_NEGATIVE_ONE_EXT = $87DF; + GL_NORMALIZED_RANGE_EXT = $87E0; + GL_FULL_RANGE_EXT = $87E1; + GL_CURRENT_VERTEX_EXT = $87E2; + GL_MVP_MATRIX_EXT = $87E3; + GL_VARIANT_VALUE_EXT = $87E4; + GL_VARIANT_DATATYPE_EXT = $87E5; + GL_VARIANT_ARRAY_STRIDE_EXT = $87E6; + GL_VARIANT_ARRAY_TYPE_EXT = $87E7; + GL_VARIANT_ARRAY_EXT = $87E8; + GL_VARIANT_ARRAY_POINTER_EXT = $87E9; + GL_INVARIANT_VALUE_EXT = $87EA; + GL_INVARIANT_DATATYPE_EXT = $87EB; + GL_LOCAL_CONSTANT_VALUE_EXT = $87EC; + GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED; + // GL_EXT_vertex_weighting + GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3; + GL_MODELVIEW1_STACK_DEPTH_EXT = $8502; + GL_MODELVIEW0_MATRIX_EXT = $0BA6; + GL_MODELVIEW1_MATRIX_EXT = $8506; + GL_VERTEX_WEIGHTING_EXT = $8509; + GL_MODELVIEW0_EXT = $1700; + GL_MODELVIEW1_EXT = $850A; + GL_CURRENT_VERTEX_WEIGHT_EXT = $850B; + GL_VERTEX_WEIGHT_ARRAY_EXT = $850C; + GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D; + GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E; + GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F; + GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510; + // GL_EXT_depth_bounds_test + GL_DEPTH_BOUNDS_TEST_EXT = $8890; + GL_DEPTH_BOUNDS_EXT = $8891; + // GL_EXT_texture_mirror_clamp + GL_MIRROR_CLAMP_EXT = $8742; + GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743; + GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912; + // GL_EXT_blend_equation_separate + GL_BLEND_EQUATION_RGB_EXT = $8009; + GL_BLEND_EQUATION_ALPHA_EXT = $883D; + // GL_EXT_pixel_buffer_object + GL_PIXEL_PACK_BUFFER_EXT = $88EB; + GL_PIXEL_UNPACK_BUFFER_EXT = $88EC; + GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED; + GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF; + // GL_EXT_stencil_clear_tag + GL_STENCIL_TAG_BITS_EXT = $88F2; + GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3; + // GL_EXT_packed_depth_stencil + GL_DEPTH_STENCIL_EXT = $84F9; + GL_UNSIGNED_INT_24_8_EXT = $84FA; + GL_DEPTH24_STENCIL8_EXT = $88F0; + GL_TEXTURE_STENCIL_SIZE_EXT = $88F1; + // GL_EXT_texture_sRGB + GL_SRGB_EXT = $8C40; + GL_SRGB8_EXT = $8C41; + GL_SRGB_ALPHA_EXT = $8C42; + GL_SRGB8_ALPHA8_EXT = $8C43; + GL_SLUMINANCE_ALPHA_EXT = $8C44; + GL_SLUMINANCE8_ALPHA8_EXT = $8C45; + GL_SLUMINANCE_EXT = $8C46; + GL_SLUMINANCE8_EXT = $8C47; + GL_COMPRESSED_SRGB_EXT = $8C48; + GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49; + GL_COMPRESSED_SLUMINANCE_EXT = $8C4A; + GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B; + GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C; + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D; + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E; + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F; + // GL_EXT_framebuffer_blit + GL_READ_FRAMEBUFFER_EXT = $8CA8; + GL_DRAW_FRAMEBUFFER_EXT = $8CA9; + GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT; + GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA; + // GL_EXT_framebuffer_multisample + GL_RENDERBUFFER_SAMPLES_EXT = $8CAB; + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56; + GL_MAX_SAMPLES_EXT = $8D57; + // GL_EXT_timer_query + GL_TIME_ELAPSED_EXT = $88BF; + // GL_EXT_bindable_uniform + GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2; + GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3; + GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4; + GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED; + GL_UNIFORM_BUFFER_EXT = $8DEE; + GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF; + // GL_EXT_framebuffer_sRGB + GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; + WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9; + GL_FRAMEBUFFER_SRGB_EXT = $8DB9; + GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA; + + // GL_EXT_geometry_shader4 + GL_GEOMETRY_SHADER_EXT = $8DD9; + GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA; + GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB; + GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29; + GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD; + GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE; + GL_MAX_VARYING_COMPONENTS_EXT = $8B4B; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1; + GL_LINES_ADJACENCY_EXT = $A; + GL_LINE_STRIP_ADJACENCY_EXT = $B; + GL_TRIANGLES_ADJACENCY_EXT = $C; + GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4; + GL_PROGRAM_POINT_SIZE_EXT = $8642; + + // GL_EXT_gpu_shader4 + GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD; + GL_SAMPLER_1D_ARRAY_EXT = $8DC0; + GL_SAMPLER_2D_ARRAY_EXT = $8DC1; + GL_SAMPLER_BUFFER_EXT = $8DC2; + GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3; + GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4; + GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5; + GL_UNSIGNED_INT_VEC2_EXT = $8DC6; + GL_UNSIGNED_INT_VEC3_EXT = $8DC7; + GL_UNSIGNED_INT_VEC4_EXT = $8DC8; + GL_INT_SAMPLER_1D_EXT = $8DC9; + GL_INT_SAMPLER_2D_EXT = $8DCA; + GL_INT_SAMPLER_3D_EXT = $8DCB; + GL_INT_SAMPLER_CUBE_EXT = $8DCC; + GL_INT_SAMPLER_2D_RECT_EXT = $8DCD; + GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE; + GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF; + GL_INT_SAMPLER_BUFFER_EXT = $8DD0; + GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1; + GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2; + GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3; + GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4; + GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5; + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6; + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7; + GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8; + GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904; + GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905; + + // GL_EXT_packed_float + GL_R11F_G11F_B10F_EXT = $8C3A; + GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B; + RGBA_SIGNED_COMPONENTS_EXT = $8C3C; + WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8; + GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; + GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; + + // GL_EXT_texture_array + GL_TEXTURE_1D_ARRAY_EXT = $8C18; + GL_TEXTURE_2D_ARRAY_EXT = $8C1A; + GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B; + GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19; + GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C; + GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D; + GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF; + GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E; + + // GL_EXT_texture_buffer_object + GL_TEXTURE_BUFFER_EXT = $8C2A; + GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B; + GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C; + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D; + GL_TEXTURE_BUFFER_FORMAT_EXT = $8C2E; + + // GL_EXT_texture_compression_latc + GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70; + GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71; + GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72; + GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73; + + // GL_EXT_texture_compression_rgtc + GL_COMPRESSED_RED_RGTC1_EXT = $8DBB; + GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC; + GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD; + GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE; + + // GL_EXT_texture_integer + GL_RGBA_INTEGER_MODE_EXT = $8D9E; + GL_RGBA32UI_EXT = $8D70; + GL_RGB32UI_EXT = $8D71; + GL_ALPHA32UI_EXT = $8D72; + GL_INTENSITY32UI_EXT = $8D73; + GL_LUMINANCE32UI_EXT = $8D74; + GL_LUMINANCE_ALPHA32UI_EXT = $8D75; + GL_RGBA16UI_EXT = $8D76; + GL_RGB16UI_EXT = $8D77; + GL_ALPHA16UI_EXT = $8D78; + GL_INTENSITY16UI_EXT = $8D79; + GL_LUMINANCE16UI_EXT = $8D7A; + GL_LUMINANCE_ALPHA16UI_EXT = $8D7B; + GL_RGBA8UI_EXT = $8D7C; + GL_RGB8UI_EXT = $8D7D; + GL_ALPHA8UI_EXT = $8D7E; + GL_INTENSITY8UI_EXT = $8D7F; + GL_LUMINANCE8UI_EXT = $8D80; + GL_LUMINANCE_ALPHA8UI_EXT = $8D81; + GL_RGBA32I_EXT = $8D82; + GL_RGB32I_EXT = $8D83; + GL_ALPHA32I_EXT = $8D84; + GL_INTENSITY32I_EXT = $8D85; + GL_LUMINANCE32I_EXT = $8D86; + GL_LUMINANCE_ALPHA32I_EXT = $8D87; + GL_RGBA16I_EXT = $8D88; + GL_RGB16I_EXT = $8D89; + GL_ALPHA16I_EXT = $8D8A; + GL_INTENSITY16I_EXT = $8D8B; + GL_LUMINANCE16I_EXT = $8D8C; + GL_LUMINANCE_ALPHA16I_EXT = $8D8D; + GL_RGBA8I_EXT = $8D8E; + GL_RGB8I_EXT = $8D8F; + GL_ALPHA8I_EXT = $8D90; + GL_INTENSITY8I_EXT = $8D91; + GL_LUMINANCE8I_EXT = $8D92; + GL_LUMINANCE_ALPHA8I_EXT = $8D93; + GL_RED_INTEGER_EXT = $8D94; + GL_GREEN_INTEGER_EXT = $8D95; + GL_BLUE_INTEGER_EXT = $8D96; + GL_ALPHA_INTEGER_EXT = $8D97; + GL_RGB_INTEGER_EXT = $8D98; + GL_RGBA_INTEGER_EXT = $8D99; + GL_BGR_INTEGER_EXT = $8D9A; + GL_BGRA_INTEGER_EXT = $8D9B; + GL_LUMINANCE_INTEGER_EXT = $8D9C; + GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D; + + // GL_EXT_texture_shared_exponent + GL_RGB9_E5_EXT = $8C3D; + GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E; + GL_TEXTURE_SHARED_SIZE_EXT = $8C3F; + + // GL_EXT_transform_feedback + GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E; + GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84; + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85; + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F; + GL_INTERLEAVED_ATTRIBS_EXT = $8C8C; + GL_SEPARATE_ATTRIBS_EXT = $8C8D; + GL_PRIMITIVES_GENERATED_EXT = $8C87; + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88; + GL_RASTERIZER_DISCARD_EXT = $8C89; + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80; + GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83; + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F; + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76; + + // GL_EXT_direct_state_access + GL_PROGRAM_MATRIX_EXT = $8E2D; + GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E; + GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F; + + // GL_EXT_texture_swizzle + GL_TEXTURE_SWIZZLE_R_EXT = $8E42; + GL_TEXTURE_SWIZZLE_G_EXT = $8E43; + GL_TEXTURE_SWIZZLE_B_EXT = $8E44; + GL_TEXTURE_SWIZZLE_A_EXT = $8E45; + GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46; + + // GL_EXT_provoking_vertex + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C; + GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D; + GL_LAST_VERTEX_CONVENTION_EXT = $8E4E; + GL_PROVOKING_VERTEX_EXT = $8E4F; + + // GL_EXT_texture_snorm + GL_ALPHA_SNORM = $9010; + GL_LUMINANCE_SNORM = $9011; + GL_LUMINANCE_ALPHA_SNORM = $9012; + GL_INTENSITY_SNORM = $9013; + GL_ALPHA8_SNORM = $9014; + GL_LUMINANCE8_SNORM = $9015; + GL_LUMINANCE8_ALPHA8_SNORM = $9016; + GL_INTENSITY8_SNORM = $9017; + GL_ALPHA16_SNORM = $9018; + GL_LUMINANCE16_SNORM = $9019; + GL_LUMINANCE16_ALPHA16_SNORM = $901A; + GL_INTENSITY16_SNORM = $901B; + { reuse GL_RED_SNORM } + { reuse GL_RG_SNORM } + { reuse GL_RGB_SNORM } + { reuse GL_RGBA_SNORM } + { reuse GL_R8_SNORM } + { reuse GL_RG8_SNORM } + { reuse GL_RGB8_SNORM } + { reuse GL_RGBA8_SNORM } + { reuse GL_R16_SNORM } + { reuse GL_RG16_SNORM } + { reuse GL_RGB16_SNORM } + { reuse GL_RGBA16_SNORM } + { reuse GL_SIGNED_NORMALIZED } + + // GL_EXT_separate_shader_objects + GL_ACTIVE_PROGRAM_EXT = $8B8D; + + // GL_EXT_shader_image_load_store + GL_MAX_IMAGE_UNITS_EXT = $8F38; + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = $8F39; + GL_IMAGE_BINDING_NAME_EXT = $8F3A; + GL_IMAGE_BINDING_LEVEL_EXT = $8F3B; + GL_IMAGE_BINDING_LAYERED_EXT = $8F3C; + GL_IMAGE_BINDING_LAYER_EXT = $8F3D; + GL_IMAGE_BINDING_ACCESS_EXT = $8F3E; + GL_IMAGE_1D_EXT = $904C; + GL_IMAGE_2D_EXT = $904D; + GL_IMAGE_3D_EXT = $904E; + GL_IMAGE_2D_RECT_EXT = $904F; + GL_IMAGE_CUBE_EXT = $9050; + GL_IMAGE_BUFFER_EXT = $9051; + GL_IMAGE_1D_ARRAY_EXT = $9052; + GL_IMAGE_2D_ARRAY_EXT = $9053; + GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054; + GL_IMAGE_2D_MULTISAMPLE_EXT = $9055; + GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9056; + GL_INT_IMAGE_1D_EXT = $9057; + GL_INT_IMAGE_2D_EXT = $9058; + GL_INT_IMAGE_3D_EXT = $9059; + GL_INT_IMAGE_2D_RECT_EXT = $905A; + GL_INT_IMAGE_CUBE_EXT = $905B; + GL_INT_IMAGE_BUFFER_EXT = $905C; + GL_INT_IMAGE_1D_ARRAY_EXT = $905D; + GL_INT_IMAGE_2D_ARRAY_EXT = $905E; + GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F; + GL_INT_IMAGE_2D_MULTISAMPLE_EXT = $9060; + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9061; + GL_UNSIGNED_INT_IMAGE_1D_EXT = $9062; + GL_UNSIGNED_INT_IMAGE_2D_EXT = $9063; + GL_UNSIGNED_INT_IMAGE_3D_EXT = $9064; + GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = $9065; + GL_UNSIGNED_INT_IMAGE_CUBE_EXT = $9066; + GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067; + GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = $9068; + GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = $9069; + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = $906B; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $906C; + GL_MAX_IMAGE_SAMPLES_EXT = $906D; + GL_IMAGE_BINDING_FORMAT_EXT = $906E; + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = $00000001; + GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = $00000002; + GL_UNIFORM_BARRIER_BIT_EXT = $00000004; + GL_TEXTURE_FETCH_BARRIER_BIT_EXT = $00000008; + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = $00000020; + GL_COMMAND_BARRIER_BIT_EXT = $00000040; + GL_PIXEL_BUFFER_BARRIER_BIT_EXT = $00000080; + GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = $00000100; + GL_BUFFER_UPDATE_BARRIER_BIT_EXT = $00000200; + GL_FRAMEBUFFER_BARRIER_BIT_EXT = $00000400; + GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = $00000800; + GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = $00001000; + GL_ALL_BARRIER_BITS_EXT = $FFFFFFFF; + + // GL_EXT_vertex_attrib_64bit + GL_DOUBLE_VEC2_EXT = $8FFC; + GL_DOUBLE_VEC3_EXT = $8FFD; + GL_DOUBLE_VEC4_EXT = $8FFE; + GL_DOUBLE_MAT2_EXT = $8F46; + GL_DOUBLE_MAT3_EXT = $8F47; + GL_DOUBLE_MAT4_EXT = $8F48; + GL_DOUBLE_MAT2x3_EXT = $8F49; + GL_DOUBLE_MAT2x4_EXT = $8F4A; + GL_DOUBLE_MAT3x2_EXT = $8F4B; + GL_DOUBLE_MAT3x4_EXT = $8F4C; + GL_DOUBLE_MAT4x2_EXT = $8F4D; + GL_DOUBLE_MAT4x3_EXT = $8F4E; + + // GL_EXT_texture_sRGB_decode + GL_TEXTURE_SRGB_DECODE_EXT = $8A48; + GL_DECODE_EXT = $8A49; + GL_SKIP_DECODE_EXT = $8A4A; + + // GL_NV_texture_multisample + GL_TEXTURE_COVERAGE_SAMPLES_NV = $9045; + GL_TEXTURE_COLOR_SAMPLES_NV = $9046; + + // GL_AMD_blend_minmax_factor + GL_FACTOR_MIN_AMD = $901C; + GL_FACTOR_MAX_AMD = $901D; + + // GL_AMD_sample_positions + GL_SUBSAMPLE_DISTANCE_AMD = $883F; + + // GL_EXT_x11_sync_object + GL_SYNC_X11_FENCE_EXT = $90E1; + + // GL_EXT_framebuffer_multisample_blit_scaled + GL_SCALED_RESOLVE_FASTEST_EXT = $90BA; + GL_SCALED_RESOLVE_NICEST_EXT = $90BB; + + // (4.3) GL_NV_path_rendering + GL_PATH_FORMAT_SVG_NV = $9070; + GL_PATH_FORMAT_PS_NV = $9071; + GL_STANDARD_FONT_NAME_NV = $9072; + GL_SYSTEM_FONT_NAME_NV = $9073; + GL_FILE_NAME_NV = $9074; + GL_PATH_STROKE_WIDTH_NV = $9075; + GL_PATH_END_CAPS_NV = $9076; + GL_PATH_INITIAL_END_CAP_NV = $9077; + GL_PATH_TERMINAL_END_CAP_NV = $9078; + GL_PATH_JOIN_STYLE_NV = $9079; + GL_PATH_MITER_LIMIT_NV = $907A; + GL_PATH_DASH_CAPS_NV = $907B; + GL_PATH_INITIAL_DASH_CAP_NV = $907C; + GL_PATH_TERMINAL_DASH_CAP_NV = $907D; + GL_PATH_DASH_OFFSET_NV = $907E; + GL_PATH_CLIENT_LENGTH_NV = $907F; + GL_PATH_FILL_MODE_NV = $9080; + GL_PATH_FILL_MASK_NV = $9081; + GL_PATH_FILL_COVER_MODE_NV = $9082; + GL_PATH_STROKE_COVER_MODE_NV = $9083; + GL_PATH_STROKE_MASK_NV = $9084; + GL_PATH_SAMPLE_QUALITY_NV = $9085; + GL_PATH_STROKE_BOUND_NV = $9086; + GL_PATH_STROKE_OVERSAMPLE_COUNT_NV= $9087; + GL_COUNT_UP_NV = $9088; + GL_COUNT_DOWN_NV = $9089; + GL_PATH_OBJECT_BOUNDING_BOX_NV = $908A; + GL_CONVEX_HULL_NV = $908B; + GL_MULTI_HULLS_NV = $908C; + GL_BOUNDING_BOX_NV = $908D; + GL_TRANSLATE_X_NV = $908E; + GL_TRANSLATE_Y_NV = $908F; + GL_TRANSLATE_2D_NV = $9090; + GL_TRANSLATE_3D_NV = $9091; + GL_AFFINE_2D_NV = $9092; + GL_PROJECTIVE_2D_NV = $9093; + GL_AFFINE_3D_NV = $9094; + GL_PROJECTIVE_3D_NV = $9095; + GL_TRANSPOSE_AFFINE_2D_NV = $9096; + GL_TRANSPOSE_PROJECTIVE_2D_NV = $9097; + GL_TRANSPOSE_AFFINE_3D_NV = $9098; + GL_TRANSPOSE_PROJECTIVE_3D_NV = $9099; + GL_UTF8_NV = $909A; + GL_UTF16_NV = $909B; + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV= $909C; + GL_PATH_COMMAND_COUNT_NV = $909D; + GL_PATH_COORD_COUNT_NV = $909E; + GL_PATH_DASH_ARRAY_COUNT_NV = $909F; + GL_PATH_COMPUTED_LENGTH_NV = $90A0; + GL_PATH_FILL_BOUNDING_BOX_NV = $90A1; + GL_PATH_STROKE_BOUNDING_BOX_NV = $90A2; + GL_SQUARE_NV = $90A3; + GL_ROUND_NV = $90A4; + GL_TRIANGULAR_NV = $90A5; + GL_BEVEL_NV = $90A6; + GL_MITER_REVERT_NV = $90A7; + GL_MITER_TRUNCATE_NV = $90A8; + GL_SKIP_MISSING_GLYPH_NV = $90A9; + GL_USE_MISSING_GLYPH_NV = $90AA; + GL_PATH_ERROR_POSITION_NV = $90AB; + GL_PATH_FOG_GEN_MODE_NV = $90AC; + GL_ACCUM_ADJACENT_PAIRS_NV = $90AD; + GL_ADJACENT_PAIRS_NV = $90AE; + GL_FIRST_TO_REST_NV = $90AF; + GL_PATH_GEN_MODE_NV = $90B0; + GL_PATH_GEN_COEFF_NV = $90B1; + GL_PATH_GEN_COLOR_FORMAT_NV = $90B2; + GL_PATH_GEN_COMPONENTS_NV = $90B3; + GL_PATH_STENCIL_FUNC_NV = $90B7; + GL_PATH_STENCIL_REF_NV = $90B8; + GL_PATH_STENCIL_VALUE_MASK_NV = $90B9; + GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV= $90BD; + GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV= $90BE; + GL_PATH_COVER_DEPTH_FUNC_NV = $90BF; + GL_PATH_DASH_OFFSET_RESET_NV = $90B4; + GL_MOVE_TO_RESETS_NV = $90B5; + GL_MOVE_TO_CONTINUES_NV = $90B6; + GL_CLOSE_PATH_NV = $00; + GL_MOVE_TO_NV = $02; + GL_RELATIVE_MOVE_TO_NV = $03; + GL_LINE_TO_NV = $04; + GL_RELATIVE_LINE_TO_NV = $05; + GL_HORIZONTAL_LINE_TO_NV = $06; + GL_RELATIVE_HORIZONTAL_LINE_TO_NV= $07; + GL_VERTICAL_LINE_TO_NV = $08; + GL_RELATIVE_VERTICAL_LINE_TO_NV = $09; + GL_QUADRATIC_CURVE_TO_NV = $0A; + GL_RELATIVE_QUADRATIC_CURVE_TO_NV= $0B; + GL_CUBIC_CURVE_TO_NV = $0C; + GL_RELATIVE_CUBIC_CURVE_TO_NV = $0D; + GL_SMOOTH_QUADRATIC_CURVE_TO_NV = $0E; + GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV= $0F; + GL_SMOOTH_CUBIC_CURVE_TO_NV = $10; + GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV= $11; + GL_SMALL_CCW_ARC_TO_NV = $12; + GL_RELATIVE_SMALL_CCW_ARC_TO_NV = $13; + GL_SMALL_CW_ARC_TO_NV = $14; + GL_RELATIVE_SMALL_CW_ARC_TO_NV = $15; + GL_LARGE_CCW_ARC_TO_NV = $16; + GL_RELATIVE_LARGE_CCW_ARC_TO_NV = $17; + GL_LARGE_CW_ARC_TO_NV = $18; + GL_RELATIVE_LARGE_CW_ARC_TO_NV = $19; + GL_RESTART_PATH_NV = $F0; + GL_DUP_FIRST_CUBIC_CURVE_TO_NV = $F2; + GL_DUP_LAST_CUBIC_CURVE_TO_NV = $F4; + GL_RECT_NV = $F6; + GL_CIRCULAR_CCW_ARC_TO_NV = $F8; + GL_CIRCULAR_CW_ARC_TO_NV = $FA; + GL_CIRCULAR_TANGENT_ARC_TO_NV = $FC; + GL_ARC_TO_NV = $FE; + GL_RELATIVE_ARC_TO_NV = $FF; + GL_BOLD_BIT_NV = $01; + GL_ITALIC_BIT_NV = $02; + GL_GLYPH_WIDTH_BIT_NV = $01; + GL_GLYPH_HEIGHT_BIT_NV = $02; + GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV= $04; + GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV= $08; + GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV= $10; + GL_GLYPH_VERTICAL_BEARING_X_BIT_NV= $20; + GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV= $40; + GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV= $80; + GL_GLYPH_HAS_KERNING_NV = $100; + GL_FONT_X_MIN_BOUNDS_NV = $00010000; + GL_FONT_Y_MIN_BOUNDS_NV = $00020000; + GL_FONT_X_MAX_BOUNDS_NV = $00040000; + GL_FONT_Y_MAX_BOUNDS_NV = $00080000; + GL_FONT_UNITS_PER_EM_NV = $00100000; + GL_FONT_ASCENDER_NV = $00200000; + GL_FONT_DESCENDER_NV = $00400000; + GL_FONT_HEIGHT_NV = $00800000; + GL_FONT_MAX_ADVANCE_WIDTH_NV = $01000000; + GL_FONT_MAX_ADVANCE_HEIGHT_NV = $02000000; + GL_FONT_UNDERLINE_POSITION_NV = $04000000; + GL_FONT_UNDERLINE_THICKNESS_NV = $08000000; + GL_FONT_HAS_KERNING_NV = $10000000; + + // (4.3) GL_AMD_pinned_memory + GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD= $9160; + + // (4.3) GL_AMD_stencil_operation_extended + GL_SET_AMD = $874A; + GL_REPLACE_VALUE_AMD = $874B; + GL_STENCIL_OP_VALUE_AMD = $874C; + GL_STENCIL_BACK_OP_VALUE_AMD = $874D; + + // (4.3) GL_AMD_query_buffer_object + GL_QUERY_BUFFER_AMD = $9192; + GL_QUERY_BUFFER_BINDING_AMD = $9193; + GL_QUERY_RESULT_NO_WAIT_AMD = $9194; + + // GL_FfdMaskSGIX + GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001; + GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002; + + // GL_HP_convolution_border_modes + GL_IGNORE_BORDER_HP = $8150; + GL_CONSTANT_BORDER_HP = $8151; + GL_REPLICATE_BORDER_HP = $8153; + GL_CONVOLUTION_BORDER_COLOR_HP = $8154; + + // GL_HP_image_transform + GL_IMAGE_SCALE_X_HP = $8155; + GL_IMAGE_SCALE_Y_HP = $8156; + GL_IMAGE_TRANSLATE_X_HP = $8157; + GL_IMAGE_TRANSLATE_Y_HP = $8158; + GL_IMAGE_ROTATE_ANGLE_HP = $8159; + GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A; + GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B; + GL_IMAGE_MAG_FILTER_HP = $815C; + GL_IMAGE_MIN_FILTER_HP = $815D; + GL_IMAGE_CUBIC_WEIGHT_HP = $815E; + GL_CUBIC_HP = $815F; + GL_AVERAGE_HP = $8160; + GL_IMAGE_TRANSFORM_2D_HP = $8161; + GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162; + GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163; + + // GL_HP_occlusion_test + GL_OCCLUSION_TEST_HP = $8165; + GL_OCCLUSION_TEST_RESULT_HP = $8166; + + // GL_HP_texture_lighting + GL_TEXTURE_LIGHTING_MODE_HP = $8167; + GL_TEXTURE_POST_SPECULAR_HP = $8168; + GL_TEXTURE_PRE_SPECULAR_HP = $8169; + + // GL_IBM_cull_vertex + GL_CULL_VERTEX_IBM = 103050; + + // GL_IBM_rasterpos_clip + GL_RASTER_POSITION_UNCLIPPED_IBM = $19262; + + // GL_IBM_texture_mirrored_repeat + GL_MIRRORED_REPEAT_IBM = $8370; + + // GL_IBM_vertex_array_lists + GL_VERTEX_ARRAY_LIST_IBM = 103070; + GL_NORMAL_ARRAY_LIST_IBM = 103071; + GL_COLOR_ARRAY_LIST_IBM = 103072; + GL_INDEX_ARRAY_LIST_IBM = 103073; + GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074; + GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075; + GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076; + GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077; + GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080; + GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081; + GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082; + GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083; + GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084; + GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085; + GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086; + GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087; + + // GL_INGR_color_clamp + GL_RED_MIN_CLAMP_INGR = $8560; + GL_GREEN_MIN_CLAMP_INGR = $8561; + GL_BLUE_MIN_CLAMP_INGR = $8562; + GL_ALPHA_MIN_CLAMP_INGR = $8563; + GL_RED_MAX_CLAMP_INGR = $8564; + GL_GREEN_MAX_CLAMP_INGR = $8565; + GL_BLUE_MAX_CLAMP_INGR = $8566; + GL_ALPHA_MAX_CLAMP_INGR = $8567; + + // GL_INGR_interlace_read + GL_INTERLACE_READ_INGR = $8568; + + // GL_INTEL_parallel_arrays + GL_PARALLEL_ARRAYS_INTEL = $83F4; + GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5; + GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6; + GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7; + GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8; + + // GL_NV_copy_depth_to_color + GL_DEPTH_STENCIL_TO_RGBA_NV = $886E; + GL_DEPTH_STENCIL_TO_BGRA_NV = $886F; + + // GL_NV_depth_clamp + GL_DEPTH_CLAMP_NV = $864F; + + // GL_NV_evaluators + GL_EVAL_2D_NV = $86C0; + GL_EVAL_TRIANGULAR_2D_NV = $86C1; + GL_MAP_TESSELLATION_NV = $86C2; + GL_MAP_ATTRIB_U_ORDER_NV = $86C3; + GL_MAP_ATTRIB_V_ORDER_NV = $86C4; + GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5; + GL_EVAL_VERTEX_ATTRIB0_NV = $86C6; + GL_EVAL_VERTEX_ATTRIB1_NV = $86C7; + GL_EVAL_VERTEX_ATTRIB2_NV = $86C8; + GL_EVAL_VERTEX_ATTRIB3_NV = $86C9; + GL_EVAL_VERTEX_ATTRIB4_NV = $86CA; + GL_EVAL_VERTEX_ATTRIB5_NV = $86CB; + GL_EVAL_VERTEX_ATTRIB6_NV = $86CC; + GL_EVAL_VERTEX_ATTRIB7_NV = $86CD; + GL_EVAL_VERTEX_ATTRIB8_NV = $86CE; + GL_EVAL_VERTEX_ATTRIB9_NV = $86CF; + GL_EVAL_VERTEX_ATTRIB10_NV = $86D0; + GL_EVAL_VERTEX_ATTRIB11_NV = $86D1; + GL_EVAL_VERTEX_ATTRIB12_NV = $86D2; + GL_EVAL_VERTEX_ATTRIB13_NV = $86D3; + GL_EVAL_VERTEX_ATTRIB14_NV = $86D4; + GL_EVAL_VERTEX_ATTRIB15_NV = $86D5; + GL_MAX_MAP_TESSELLATION_NV = $86D6; + GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7; + + // GL_NV_fence + GL_ALL_COMPLETED_NV = $84F2; + GL_FENCE_STATUS_NV = $84F3; + GL_FENCE_CONDITION_NV = $84F4; + + // GL_NV_float_buffer + GL_FLOAT_R_NV = $8880; + GL_FLOAT_RG_NV = $8881; + GL_FLOAT_RGB_NV = $8882; + GL_FLOAT_RGBA_NV = $8883; + GL_FLOAT_R16_NV = $8884; + GL_FLOAT_R32_NV = $8885; + GL_FLOAT_RG16_NV = $8886; + GL_FLOAT_RG32_NV = $8887; + GL_FLOAT_RGB16_NV = $8888; + GL_FLOAT_RGB32_NV = $8889; + GL_FLOAT_RGBA16_NV = $888A; + GL_FLOAT_RGBA32_NV = $888B; + GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C; + GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D; + GL_FLOAT_RGBA_MODE_NV = $888E; + + // GL_NV_fog_distance + GL_FOG_DISTANCE_MODE_NV = $855A; + GL_EYE_RADIAL_NV = $855B; + GL_EYE_PLANE_ABSOLUTE_NV = $855C; + + // GL_NV_fragment_program + GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868; + GL_FRAGMENT_PROGRAM_NV = $8870; + GL_MAX_TEXTURE_COORDS_NV = $8871; + GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872; + GL_FRAGMENT_PROGRAM_BINDING_NV = $8873; + GL_PROGRAM_ERROR_STRING_NV = $8874; + + // GL_NV_half_float + GL_HALF_FLOAT_NV = $140B; + + // GL_NV_light_max_exponent + GL_MAX_SHININESS_NV = $8504; + GL_MAX_SPOT_EXPONENT_NV = $8505; + + // GL_NV_multisample_filter_hint + GL_MULTISAMPLE_FILTER_HINT_NV = $8534; + + // GL_NV_occlusion_query + GL_PIXEL_COUNTER_BITS_NV = $8864; + GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865; + GL_PIXEL_COUNT_NV = $8866; + GL_PIXEL_COUNT_AVAILABLE_NV = $8867; + + // GL_NV_packed_depth_stencil + GL_DEPTH_STENCIL_NV = $84F9; + GL_UNSIGNED_INT_24_8_NV = $84FA; + + // GL_NV_pixel_data_range + GL_WRITE_PIXEL_DATA_RANGE_NV = $8878; + GL_READ_PIXEL_DATA_RANGE_NV = $8879; + GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A; + GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B; + GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C; + GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D; + + // GL_NV_point_sprite + GL_POINT_SPRITE_NV = $8861; + GL_COORD_REPLACE_NV = $8862; + GL_POINT_SPRITE_R_MODE_NV = $8863; + + // GL_NV_primitive_restart + GL_PRIMITIVE_RESTART_NV = $8558; + GL_PRIMITIVE_RESTART_INDEX_NV = $8559; + + // GL_NV_register_combiners + GL_REGISTER_COMBINERS_NV = $8522; + GL_VARIABLE_A_NV = $8523; + GL_VARIABLE_B_NV = $8524; + GL_VARIABLE_C_NV = $8525; + GL_VARIABLE_D_NV = $8526; + GL_VARIABLE_E_NV = $8527; + GL_VARIABLE_F_NV = $8528; + GL_VARIABLE_G_NV = $8529; + GL_CONSTANT_COLOR0_NV = $852A; + GL_CONSTANT_COLOR1_NV = $852B; + GL_PRIMARY_COLOR_NV = $852C; + GL_SECONDARY_COLOR_NV = $852D; + GL_SPARE0_NV = $852E; + GL_SPARE1_NV = $852F; + GL_DISCARD_NV = $8530; + GL_E_TIMES_F_NV = $8531; + GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532; + GL_UNSIGNED_IDENTITY_NV = $8536; + GL_UNSIGNED_INVERT_NV = $8537; + GL_EXPAND_NORMAL_NV = $8538; + GL_EXPAND_NEGATE_NV = $8539; + GL_HALF_BIAS_NORMAL_NV = $853A; + GL_HALF_BIAS_NEGATE_NV = $853B; + GL_SIGNED_IDENTITY_NV = $853C; + GL_SIGNED_NEGATE_NV = $853D; + GL_SCALE_BY_TWO_NV = $853E; + GL_SCALE_BY_FOUR_NV = $853F; + GL_SCALE_BY_ONE_HALF_NV = $8540; + GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541; + GL_COMBINER_INPUT_NV = $8542; + GL_COMBINER_MAPPING_NV = $8543; + GL_COMBINER_COMPONENT_USAGE_NV = $8544; + GL_COMBINER_AB_DOT_PRODUCT_NV = $8545; + GL_COMBINER_CD_DOT_PRODUCT_NV = $8546; + GL_COMBINER_MUX_SUM_NV = $8547; + GL_COMBINER_SCALE_NV = $8548; + GL_COMBINER_BIAS_NV = $8549; + GL_COMBINER_AB_OUTPUT_NV = $854A; + GL_COMBINER_CD_OUTPUT_NV = $854B; + GL_COMBINER_SUM_OUTPUT_NV = $854C; + GL_MAX_GENERAL_COMBINERS_NV = $854D; + GL_NUM_GENERAL_COMBINERS_NV = $854E; + GL_COLOR_SUM_CLAMP_NV = $854F; + GL_COMBINER0_NV = $8550; + GL_COMBINER1_NV = $8551; + GL_COMBINER2_NV = $8552; + GL_COMBINER3_NV = $8553; + GL_COMBINER4_NV = $8554; + GL_COMBINER5_NV = $8555; + GL_COMBINER6_NV = $8556; + GL_COMBINER7_NV = $8557; + + // GL_NV_register_combiners2 + GL_PER_STAGE_CONSTANTS_NV = $8535; + + // GL_NV_texgen_emboss + GL_EMBOSS_LIGHT_NV = $855D; + GL_EMBOSS_CONSTANT_NV = $855E; + GL_EMBOSS_MAP_NV = $855F; + + // GL_NV_texgen_reflection + GL_NORMAL_MAP_NV = $8511; + GL_REFLECTION_MAP_NV = $8512; + + // GL_NV_texture_env_combine4 + GL_COMBINE4_NV = $8503; + GL_SOURCE3_RGB_NV = $8583; + GL_SOURCE3_ALPHA_NV = $858B; + GL_OPERAND3_RGB_NV = $8593; + GL_OPERAND3_ALPHA_NV = $859B; + + // GL_NV_texture_expand_normal + GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F; + + // GL_NV_texture_rectangle + GL_TEXTURE_RECTANGLE_NV = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8; + + // GL_NV_texture_shader + GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C; + GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D; + GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E; + GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9; + GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA; + GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB; + GL_DSDT_MAG_INTENSITY_NV = $86DC; + GL_SHADER_CONSISTENT_NV = $86DD; + GL_TEXTURE_SHADER_NV = $86DE; + GL_SHADER_OPERATION_NV = $86DF; + GL_CULL_MODES_NV = $86E0; + GL_OFFSET_TEXTURE_MATRIX_NV = $86E1; + GL_OFFSET_TEXTURE_SCALE_NV = $86E2; + GL_OFFSET_TEXTURE_BIAS_NV = $86E3; + GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV; + GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV; + GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV; + GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4; + GL_CONST_EYE_NV = $86E5; + GL_PASS_THROUGH_NV = $86E6; + GL_CULL_FRAGMENT_NV = $86E7; + GL_OFFSET_TEXTURE_2D_NV = $86E8; + GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9; + GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA; + GL_DOT_PRODUCT_NV = $86EC; + GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED; + GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE; + GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0; + GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1; + GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2; + GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3; + GL_HILO_NV = $86F4; + GL_DSDT_NV = $86F5; + GL_DSDT_MAG_NV = $86F6; + GL_DSDT_MAG_VIB_NV = $86F7; + GL_HILO16_NV = $86F8; + GL_SIGNED_HILO_NV = $86F9; + GL_SIGNED_HILO16_NV = $86FA; + GL_SIGNED_RGBA_NV = $86FB; + GL_SIGNED_RGBA8_NV = $86FC; + GL_SIGNED_RGB_NV = $86FE; + GL_SIGNED_RGB8_NV = $86FF; + GL_SIGNED_LUMINANCE_NV = $8701; + GL_SIGNED_LUMINANCE8_NV = $8702; + GL_SIGNED_LUMINANCE_ALPHA_NV = $8703; + GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704; + GL_SIGNED_ALPHA_NV = $8705; + GL_SIGNED_ALPHA8_NV = $8706; + GL_SIGNED_INTENSITY_NV = $8707; + GL_SIGNED_INTENSITY8_NV = $8708; + GL_DSDT8_NV = $8709; + GL_DSDT8_MAG8_NV = $870A; + GL_DSDT8_MAG8_INTENSITY8_NV = $870B; + GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C; + GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D; + GL_HI_SCALE_NV = $870E; + GL_LO_SCALE_NV = $870F; + GL_DS_SCALE_NV = $8710; + GL_DT_SCALE_NV = $8711; + GL_MAGNITUDE_SCALE_NV = $8712; + GL_VIBRANCE_SCALE_NV = $8713; + GL_HI_BIAS_NV = $8714; + GL_LO_BIAS_NV = $8715; + GL_DS_BIAS_NV = $8716; + GL_DT_BIAS_NV = $8717; + GL_MAGNITUDE_BIAS_NV = $8718; + GL_VIBRANCE_BIAS_NV = $8719; + GL_TEXTURE_BORDER_VALUES_NV = $871A; + GL_TEXTURE_HI_SIZE_NV = $871B; + GL_TEXTURE_LO_SIZE_NV = $871C; + GL_TEXTURE_DS_SIZE_NV = $871D; + GL_TEXTURE_DT_SIZE_NV = $871E; + GL_TEXTURE_MAG_SIZE_NV = $871F; + + // GL_NV_texture_shader2 + GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF; + + // GL_NV_texture_shader3 + GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850; + GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851; + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852; + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853; + GL_OFFSET_HILO_TEXTURE_2D_NV = $8854; + GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855; + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856; + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857; + GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858; + GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859; + GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A; + GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B; + GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C; + GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D; + GL_HILO8_NV = $885E; + GL_SIGNED_HILO8_NV = $885F; + GL_FORCE_BLUE_TO_ONE_NV = $8860; + + // GL_NV_vertex_array_range + GL_VERTEX_ARRAY_RANGE_NV = $851D; + GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E; + GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F; + GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520; + GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521; + + // GL_NV_vertex_array_range2 + GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533; + + // GL_NV_vertex_program + GL_VERTEX_PROGRAM_NV = $8620; + GL_VERTEX_STATE_PROGRAM_NV = $8621; + GL_ATTRIB_ARRAY_SIZE_NV = $8623; + GL_ATTRIB_ARRAY_STRIDE_NV = $8624; + GL_ATTRIB_ARRAY_TYPE_NV = $8625; + GL_CURRENT_ATTRIB_NV = $8626; + GL_PROGRAM_LENGTH_NV = $8627; + GL_PROGRAM_STRING_NV = $8628; + GL_MODELVIEW_PROJECTION_NV = $8629; + GL_IDENTITY_NV = $862A; + GL_INVERSE_NV = $862B; + GL_TRANSPOSE_NV = $862C; + GL_INVERSE_TRANSPOSE_NV = $862D; + GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E; + GL_MAX_TRACK_MATRICES_NV = $862F; + GL_MATRIX0_NV = $8630; + GL_MATRIX1_NV = $8631; + GL_MATRIX2_NV = $8632; + GL_MATRIX3_NV = $8633; + GL_MATRIX4_NV = $8634; + GL_MATRIX5_NV = $8635; + GL_MATRIX6_NV = $8636; + GL_MATRIX7_NV = $8637; + GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640; + GL_CURRENT_MATRIX_NV = $8641; + GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642; + GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643; + GL_PROGRAM_PARAMETER_NV = $8644; + GL_ATTRIB_ARRAY_POINTER_NV = $8645; + GL_PROGRAM_TARGET_NV = $8646; + GL_PROGRAM_RESIDENT_NV = $8647; + GL_TRACK_MATRIX_NV = $8648; + GL_TRACK_MATRIX_TRANSFORM_NV = $8649; + GL_VERTEX_PROGRAM_BINDING_NV = $864A; + GL_PROGRAM_ERROR_POSITION_NV = $864B; + GL_VERTEX_ATTRIB_ARRAY0_NV = $8650; + GL_VERTEX_ATTRIB_ARRAY1_NV = $8651; + GL_VERTEX_ATTRIB_ARRAY2_NV = $8652; + GL_VERTEX_ATTRIB_ARRAY3_NV = $8653; + GL_VERTEX_ATTRIB_ARRAY4_NV = $8654; + GL_VERTEX_ATTRIB_ARRAY5_NV = $8655; + GL_VERTEX_ATTRIB_ARRAY6_NV = $8656; + GL_VERTEX_ATTRIB_ARRAY7_NV = $8657; + GL_VERTEX_ATTRIB_ARRAY8_NV = $8658; + GL_VERTEX_ATTRIB_ARRAY9_NV = $8659; + GL_VERTEX_ATTRIB_ARRAY10_NV = $865A; + GL_VERTEX_ATTRIB_ARRAY11_NV = $865B; + GL_VERTEX_ATTRIB_ARRAY12_NV = $865C; + GL_VERTEX_ATTRIB_ARRAY13_NV = $865D; + GL_VERTEX_ATTRIB_ARRAY14_NV = $865E; + GL_VERTEX_ATTRIB_ARRAY15_NV = $865F; + GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660; + GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661; + GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662; + GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663; + GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664; + GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665; + GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666; + GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667; + GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668; + GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669; + GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A; + GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B; + GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C; + GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D; + GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E; + GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F; + GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670; + GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671; + GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672; + GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673; + GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674; + GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675; + GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676; + GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677; + GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678; + GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679; + GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A; + GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B; + GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C; + GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D; + GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E; + GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F; + + // GL_NV_fragment_program2 and GL_NV_vertex_program2_option + GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4; + GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5; + + // GL_NV_fragment_program2 + GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6; + GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7; + GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8; + + // GL_NV_vertex_program3 + MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; + + // GL_NV_depth_buffer_float + GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD; + GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF; + + // GL_NV_framebuffer_multisample_coverage + GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB; + GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10; + + // GL_NV_geometry_program4 + GL_GEOMETRY_PROGRAM_NV = $8C26; + GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27; + GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28; + + // GL_NV_gpu_program4 + GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906; + GL_PROGRAM_RESULT_COMPONENTS_NV = $8907; + GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908; + GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909; + GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5; + GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6; + + // GL_NV_parameter_buffer_object + GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0; + GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1; + GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2; + GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3; + GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4; + + // GL_NV_transform_feedback + GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E; + GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84; + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85; + GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86; + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F; + GL_INTERLEAVED_ATTRIBS_NV = $8C8C; + GL_SEPARATE_ATTRIBS_NV = $8C8D; + GL_PRIMITIVES_GENERATED_NV = $8C87; + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88; + GL_RASTERIZER_DISCARD_NV = $8C89; + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80; + GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E; + GL_ACTIVE_VARYINGS_NV = $8C81; + GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82; + GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83; + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F; + GL_BACK_PRIMARY_COLOR_NV = $8C77; + GL_BACK_SECONDARY_COLOR_NV = $8C78; + GL_TEXTURE_COORD_NV = $8C79; + GL_CLIP_DISTANCE_NV = $8C7A; + GL_VERTEX_ID_NV = $8C7B; + GL_PRIMITIVE_ID_NV = $8C7C; + GL_GENERIC_ATTRIB_NV = $8C7D; + GL_LAYER_NV = $8DAA; + GL_NEXT_BUFFER_NV = -2; + GL_SKIP_COMPONENTS4_NV = -3; + GL_SKIP_COMPONENTS3_NV = -4; + GL_SKIP_COMPONENTS2_NV = -5; + GL_SKIP_COMPONENTS1_NV = -6; + + // GL_NV_conditional_render + GL_QUERY_WAIT_NV = $8E13; + GL_QUERY_NO_WAIT_NV = $8E14; + GL_QUERY_BY_REGION_WAIT_NV = $8E15; + GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16; + + // GL_NV_present_video + GL_FRAME_NV = $8E26; + GL_FIELDS_NV = $8E27; + GL_CURRENT_TIME_NV = $8E28; + GL_NUM_FILL_STREAMS_NV = $8E29; + GL_PRESENT_TIME_NV = $8E2A; + GL_PRESENT_DURATION_NV = $8E2B; + + // GL_NV_explicit_multisample + GL_SAMPLE_POSITION_NV = $8E50; + GL_SAMPLE_MASK_NV = $8E51; + GL_SAMPLE_MASK_VALUE_NV = $8E52; + GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53; + GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54; + GL_TEXTURE_RENDERBUFFER_NV = $8E55; + GL_SAMPLER_RENDERBUFFER_NV = $8E56; + GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57; + GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58; + GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59; + + // GL_NV_transform_feedback2 + GL_TRANSFORM_FEEDBACK_NV = $8E22; + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23; + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24; + GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25; + + // GL_NV_video_capture + GL_VIDEO_BUFFER_NV = $9020; + GL_VIDEO_BUFFER_BINDING_NV = $9021; + GL_FIELD_UPPER_NV = $9022; + GL_FIELD_LOWER_NV = $9023; + GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024; + GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025; + GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026; + GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027; + GL_VIDEO_BUFFER_PITCH_NV = $9028; + GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029; + GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A; + GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B; + GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C; + GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D; + GL_PARTIAL_SUCCESS_NV = $902E; + GL_SUCCESS_NV = $902F; + GL_FAILURE_NV = $9030; + GL_YCBYCR8_422_NV = $9031; + GL_YCBAYCR8A_4224_NV = $9032; + GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033; + GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034; + GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035; + GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036; + GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037; + GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038; + GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039; + GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A; + GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B; + GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C; + + // GL_NV_shader_buffer_load + GL_BUFFER_GPU_ADDRESS_NV = $8F1D; + GL_GPU_ADDRESS_NV = $8F34; + GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35; + + // GL_NV_vertex_buffer_unified_memory + GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E; + GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F; + GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20; + GL_VERTEX_ARRAY_ADDRESS_NV = $8F21; + GL_NORMAL_ARRAY_ADDRESS_NV = $8F22; + GL_COLOR_ARRAY_ADDRESS_NV = $8F23; + GL_INDEX_ARRAY_ADDRESS_NV = $8F24; + GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25; + GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26; + GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27; + GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28; + GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29; + GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A; + GL_VERTEX_ARRAY_LENGTH_NV = $8F2B; + GL_NORMAL_ARRAY_LENGTH_NV = $8F2C; + GL_COLOR_ARRAY_LENGTH_NV = $8F2D; + GL_INDEX_ARRAY_LENGTH_NV = $8F2E; + GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F; + GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30; + GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31; + GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32; + GL_ELEMENT_ARRAY_LENGTH_NV = $8F33; + GL_DRAW_INDIRECT_UNIFIED_NV = $8F40; + GL_DRAW_INDIRECT_ADDRESS_NV = $8F41; + GL_DRAW_INDIRECT_LENGTH_NV = $8F42; + + // GL_NV_gpu_program5 + GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A; + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B; + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C; + GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D; + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F; + GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44; + GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45; + + // GL_NV_gpu_shader5 + GL_INT64_NV = $140E; + GL_UNSIGNED_INT64_NV = $140F; + GL_INT8_NV = $8FE0; + GL_INT8_VEC2_NV = $8FE1; + GL_INT8_VEC3_NV = $8FE2; + GL_INT8_VEC4_NV = $8FE3; + GL_INT16_NV = $8FE4; + GL_INT16_VEC2_NV = $8FE5; + GL_INT16_VEC3_NV = $8FE6; + GL_INT16_VEC4_NV = $8FE7; + GL_INT64_VEC2_NV = $8FE9; + GL_INT64_VEC3_NV = $8FEA; + GL_INT64_VEC4_NV = $8FEB; + GL_UNSIGNED_INT8_NV = $8FEC; + GL_UNSIGNED_INT8_VEC2_NV = $8FED; + GL_UNSIGNED_INT8_VEC3_NV = $8FEE; + GL_UNSIGNED_INT8_VEC4_NV = $8FEF; + GL_UNSIGNED_INT16_NV = $8FF0; + GL_UNSIGNED_INT16_VEC2_NV = $8FF1; + GL_UNSIGNED_INT16_VEC3_NV = $8FF2; + GL_UNSIGNED_INT16_VEC4_NV = $8FF3; + GL_UNSIGNED_INT64_VEC2_NV = $8FF5; + GL_UNSIGNED_INT64_VEC3_NV = $8FF6; + GL_UNSIGNED_INT64_VEC4_NV = $8FF7; + GL_FLOAT16_NV = $8FF8; + GL_FLOAT16_VEC2_NV = $8FF9; + GL_FLOAT16_VEC3_NV = $8FFA; + GL_FLOAT16_VEC4_NV = $8FFB; + { reuse GL_PATCHES } + + // GL_NV_shader_buffer_store + GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010; + { reuse GL_READ_WRITE } + { reuse GL_WRITE_ONLY } + + // GL_NV_tessellation_program5 + GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8; + GL_TESS_CONTROL_PROGRAM_NV = $891E; + GL_TESS_EVALUATION_PROGRAM_NV = $891F; + GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74; + GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75; + + // GL_NV_vertex_attrib_integer_64bit + { reuse GL_INT64_NV } + { reuse GL_UNSIGNED_INT64_NV } + + // GL_NV_multisample_coverage + GL_COVERAGE_SAMPLES_NV = $80A9; + GL_COLOR_SAMPLES_NV = $8E20; + + // GL_NV_vdpau_interop + GL_SURFACE_STATE_NV = $86EB; + GL_SURFACE_REGISTERED_NV = $86FD; + GL_SURFACE_MAPPED_NV = $8700; + GL_WRITE_DISCARD_NV = $88BE; + + // GL_OML_interlace + GL_INTERLACE_OML = $8980; + GL_INTERLACE_READ_OML = $8981; + + // GL_OML_resample + GL_PACK_RESAMPLE_OML = $8984; + GL_UNPACK_RESAMPLE_OML = $8985; + GL_RESAMPLE_REPLICATE_OML = $8986; + GL_RESAMPLE_ZERO_FILL_OML = $8987; + GL_RESAMPLE_AVERAGE_OML = $8988; + GL_RESAMPLE_DECIMATE_OML = $8989; + + // GL_OML_subsample + GL_FORMAT_SUBSAMPLE_24_24_OML = $8982; + GL_FORMAT_SUBSAMPLE_244_244_OML = $8983; + + // GL_PGI_misc_hints + GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8; + GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD; + GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE; + GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202; + GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203; + GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204; + GL_ALWAYS_FAST_HINT_PGI = $1A20C; + GL_ALWAYS_SOFT_HINT_PGI = $1A20D; + GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E; + GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F; + GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210; + GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211; + GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216; + GL_STRICT_LIGHTING_HINT_PGI = $1A217; + GL_STRICT_SCISSOR_HINT_PGI = $1A218; + GL_FULL_STIPPLE_HINT_PGI = $1A219; + GL_CLIP_NEAR_HINT_PGI = $1A220; + GL_CLIP_FAR_HINT_PGI = $1A221; + GL_WIDE_LINE_HINT_PGI = $1A222; + GL_BACK_NORMALS_HINT_PGI = $1A223; + + // GL_PGI_vertex_hints + GL_VERTEX_DATA_HINT_PGI = $1A22A; + GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B; + GL_MATERIAL_SIDE_HINT_PGI = $1A22C; + GL_MAX_VERTEX_HINT_PGI = $1A22D; + GL_COLOR3_BIT_PGI = $00010000; + GL_COLOR4_BIT_PGI = $00020000; + GL_EDGEFLAG_BIT_PGI = $00040000; + GL_INDEX_BIT_PGI = $00080000; + GL_MAT_AMBIENT_BIT_PGI = $00100000; + GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000; + GL_MAT_DIFFUSE_BIT_PGI = $00400000; + GL_MAT_EMISSION_BIT_PGI = $00800000; + GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000; + GL_MAT_SHININESS_BIT_PGI = $02000000; + GL_MAT_SPECULAR_BIT_PGI = $04000000; + GL_NORMAL_BIT_PGI = $08000000; + GL_TEXCOORD1_BIT_PGI = $10000000; + GL_TEXCOORD2_BIT_PGI = $20000000; + GL_TEXCOORD3_BIT_PGI = $40000000; + GL_TEXCOORD4_BIT_PGI = $80000000; + GL_VERTEX23_BIT_PGI = $00000004; + GL_VERTEX4_BIT_PGI = $00000008; + + // GL_REND_screen_coordinates + GL_SCREEN_COORDINATES_REND = $8490; + GL_INVERTED_SCREEN_W_REND = $8491; + + // GL_S3_s3tc + GL_RGB_S3TC = $83A0; + GL_RGB4_S3TC = $83A1; + GL_RGBA_S3TC = $83A2; + GL_RGBA4_S3TC = $83A3; + + // GL_SGIS_detail_texture + GL_DETAIL_TEXTURE_2D_SGIS = $8095; + GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096; + GL_LINEAR_DETAIL_SGIS = $8097; + GL_LINEAR_DETAIL_ALPHA_SGIS = $8098; + GL_LINEAR_DETAIL_COLOR_SGIS = $8099; + GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A; + GL_DETAIL_TEXTURE_MODE_SGIS = $809B; + GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C; + + // GL_SGIS_fog_function + GL_FOG_FUNC_SGIS = $812A; + GL_FOG_FUNC_POINTS_SGIS = $812B; + GL_MAX_FOG_FUNC_POINTS_SGIS = $812C; + + // GL_SGIS_generate_mipmap + GL_GENERATE_MIPMAP_SGIS = $8191; + GL_GENERATE_MIPMAP_HINT_SGIS = $8192; + + // GL_SGIS_multisample + GL_MULTISAMPLE_SGIS = $809D; + GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E; + GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F; + GL_SAMPLE_MASK_SGIS = $80A0; + GL_1PASS_SGIS = $80A1; + GL_2PASS_0_SGIS = $80A2; + GL_2PASS_1_SGIS = $80A3; + GL_4PASS_0_SGIS = $80A4; + GL_4PASS_1_SGIS = $80A5; + GL_4PASS_2_SGIS = $80A6; + GL_4PASS_3_SGIS = $80A7; + GL_SAMPLE_BUFFERS_SGIS = $80A8; + GL_SAMPLES_SGIS = $80A9; + GL_SAMPLE_MASK_VALUE_SGIS = $80AA; + GL_SAMPLE_MASK_INVERT_SGIS = $80AB; + GL_SAMPLE_PATTERN_SGIS = $80AC; + + // GL_SGIS_pixel_texture + GL_PIXEL_TEXTURE_SGIS = $8353; + GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354; + GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355; + GL_PIXEL_GROUP_COLOR_SGIS = $8356; + + // GL_SGIS_point_line_texgen + GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0; + GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1; + GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2; + GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3; + GL_EYE_POINT_SGIS = $81F4; + GL_OBJECT_POINT_SGIS = $81F5; + GL_EYE_LINE_SGIS = $81F6; + GL_OBJECT_LINE_SGIS = $81F7; + + // GL_SGIS_point_parameters + GL_POINT_SIZE_MIN_SGIS = $8126; + GL_POINT_SIZE_MAX_SGIS = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128; + GL_DISTANCE_ATTENUATION_SGIS = $8129; + + // GL_SGIS_sharpen_texture + GL_LINEAR_SHARPEN_SGIS = $80AD; + GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE; + GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF; + GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0; + + // GL_SGIS_texture4D + GL_PACK_SKIP_VOLUMES_SGIS = $8130; + GL_PACK_IMAGE_DEPTH_SGIS = $8131; + GL_UNPACK_SKIP_VOLUMES_SGIS = $8132; + GL_UNPACK_IMAGE_DEPTH_SGIS = $8133; + GL_TEXTURE_4D_SGIS = $8134; + GL_PROXY_TEXTURE_4D_SGIS = $8135; + GL_TEXTURE_4DSIZE_SGIS = $8136; + GL_TEXTURE_WRAP_Q_SGIS = $8137; + GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138; + GL_TEXTURE_4D_BINDING_SGIS = $814F; + + // GL_SGIS_texture_color_mask + GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF; + + // GL_SGIS_texture_edge_clamp + GL_CLAMP_TO_EDGE_SGIS = $812F; + + // GL_SGIS_texture_filter4 + GL_FILTER4_SGIS = $8146; + GL_TEXTURE_FILTER4_SIZE_SGIS = $8147; + + // GL_SGIS_texture_lod + GL_TEXTURE_MIN_LOD_SGIS = $813A; + GL_TEXTURE_MAX_LOD_SGIS = $813B; + GL_TEXTURE_BASE_LEVEL_SGIS = $813C; + GL_TEXTURE_MAX_LEVEL_SGIS = $813D; + + // GL_SGIS_texture_select + GL_DUAL_ALPHA4_SGIS = $8110; + GL_DUAL_ALPHA8_SGIS = $8111; + GL_DUAL_ALPHA12_SGIS = $8112; + GL_DUAL_ALPHA16_SGIS = $8113; + GL_DUAL_LUMINANCE4_SGIS = $8114; + GL_DUAL_LUMINANCE8_SGIS = $8115; + GL_DUAL_LUMINANCE12_SGIS = $8116; + GL_DUAL_LUMINANCE16_SGIS = $8117; + GL_DUAL_INTENSITY4_SGIS = $8118; + GL_DUAL_INTENSITY8_SGIS = $8119; + GL_DUAL_INTENSITY12_SGIS = $811A; + GL_DUAL_INTENSITY16_SGIS = $811B; + GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C; + GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D; + GL_QUAD_ALPHA4_SGIS = $811E; + GL_QUAD_ALPHA8_SGIS = $811F; + GL_QUAD_LUMINANCE4_SGIS = $8120; + GL_QUAD_LUMINANCE8_SGIS = $8121; + GL_QUAD_INTENSITY4_SGIS = $8122; + GL_QUAD_INTENSITY8_SGIS = $8123; + GL_DUAL_TEXTURE_SELECT_SGIS = $8124; + GL_QUAD_TEXTURE_SELECT_SGIS = $8125; + + // GL_SGIX_async + GL_ASYNC_MARKER_SGIX = $8329; + + // GL_SGIX_async_histogram + GL_ASYNC_HISTOGRAM_SGIX = $832C; + GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D; + + // GL_SGIX_async_pixel + GL_ASYNC_TEX_IMAGE_SGIX = $835C; + GL_ASYNC_DRAW_PIXELS_SGIX = $835D; + GL_ASYNC_READ_PIXELS_SGIX = $835E; + GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F; + GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360; + GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361; + + // GL_SGIX_blend_alpha_minmax + GL_ALPHA_MIN_SGIX = $8320; + GL_ALPHA_MAX_SGIX = $8321; + + // GL_SGIX_calligraphic_fragment + GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183; + + // GL_SGIX_clipmap + GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170; + GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171; + GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172; + GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173; + GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174; + GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175; + GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176; + GL_MAX_CLIPMAP_DEPTH_SGIX = $8177; + GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178; + GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D; + GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E; + GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F; + + // GL_SGIX_convolution_accuracy + GL_CONVOLUTION_HINT_SGIX = $8316; + + // GL_SGIX_depth_texture + GL_DEPTH_COMPONENT16_SGIX = $81A5; + GL_DEPTH_COMPONENT24_SGIX = $81A6; + GL_DEPTH_COMPONENT32_SGIX = $81A7; + + // GL_SGIX_fog_offset + GL_FOG_OFFSET_SGIX = $8198; + GL_FOG_OFFSET_VALUE_SGIX = $8199; + + // GL_SGIX_fog_scale + GL_FOG_SCALE_SGIX = $81FC; + GL_FOG_SCALE_VALUE_SGIX = $81FD; + + // GL_SGIX_fragment_lighting + GL_FRAGMENT_LIGHTING_SGIX = $8400; + GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401; + GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402; + GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403; + GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404; + GL_MAX_ACTIVE_LIGHTS_SGIX = $8405; + GL_CURRENT_RASTER_NORMAL_SGIX = $8406; + GL_LIGHT_ENV_MODE_SGIX = $8407; + GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408; + GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409; + GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A; + GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B; + GL_FRAGMENT_LIGHT0_SGIX = $840C; + GL_FRAGMENT_LIGHT1_SGIX = $840D; + GL_FRAGMENT_LIGHT2_SGIX = $840E; + GL_FRAGMENT_LIGHT3_SGIX = $840F; + GL_FRAGMENT_LIGHT4_SGIX = $8410; + GL_FRAGMENT_LIGHT5_SGIX = $8411; + GL_FRAGMENT_LIGHT6_SGIX = $8412; + GL_FRAGMENT_LIGHT7_SGIX = $8413; + + // GL_SGIX_framezoom + GL_FRAMEZOOM_SGIX = $818B; + GL_FRAMEZOOM_FACTOR_SGIX = $818C; + GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D; + + // GL_SGIX_impact_pixel_texture + GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184; + GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185; + GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186; + GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187; + GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188; + GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189; + GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A; + + // GL_SGIX_instruments + GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180; + GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181; + + // GL_SGIX_interlace + GL_INTERLACE_SGIX = $8094; + + // GL_SGIX_ir_instrument1 + GL_IR_INSTRUMENT1_SGIX = $817F; + + // GL_SGIX_list_priority + GL_LIST_PRIORITY_SGIX = $8182; + + // GL_SGIX_pixel_texture + GL_PIXEL_TEX_GEN_SGIX = $8139; + GL_PIXEL_TEX_GEN_MODE_SGIX = $832B; + + // GL_SGIX_pixel_tiles + GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E; + GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F; + GL_PIXEL_TILE_WIDTH_SGIX = $8140; + GL_PIXEL_TILE_HEIGHT_SGIX = $8141; + GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142; + GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143; + GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144; + GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145; + + // GL_SGIX_polynomial_ffd + GL_GEOMETRY_DEFORMATION_SGIX = $8194; + GL_TEXTURE_DEFORMATION_SGIX = $8195; + GL_DEFORMATIONS_MASK_SGIX = $8196; + GL_MAX_DEFORMATION_ORDER_SGIX = $8197; + + // GL_SGIX_reference_plane + GL_REFERENCE_PLANE_SGIX = $817D; + GL_REFERENCE_PLANE_EQUATION_SGIX = $817E; + + // GL_SGIX_resample + GL_PACK_RESAMPLE_SGIX = $842C; + GL_UNPACK_RESAMPLE_SGIX = $842D; + GL_RESAMPLE_REPLICATE_SGIX = $842E; + GL_RESAMPLE_ZERO_FILL_SGIX = $842F; + GL_RESAMPLE_DECIMATE_SGIX = $8430; + + // GL_SGIX_scalebias_hint + GL_SCALEBIAS_HINT_SGIX = $8322; + + // GL_SGIX_shadow + GL_TEXTURE_COMPARE_SGIX = $819A; + GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B; + GL_TEXTURE_LEQUAL_R_SGIX = $819C; + GL_TEXTURE_GEQUAL_R_SGIX = $819D; + + // GL_SGIX_shadow_ambient + GL_SHADOW_AMBIENT_SGIX = $80BF; + + // GL_SGIX_sprite + GL_SPRITE_SGIX = $8148; + GL_SPRITE_MODE_SGIX = $8149; + GL_SPRITE_AXIS_SGIX = $814A; + GL_SPRITE_TRANSLATION_SGIX = $814B; + GL_SPRITE_AXIAL_SGIX = $814C; + GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D; + GL_SPRITE_EYE_ALIGNED_SGIX = $814E; + + // GL_SGIX_subsample + GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0; + GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1; + GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2; + GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3; + GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4; + + // GL_SGIX_texture_add_env + GL_TEXTURE_ENV_BIAS_SGIX = $80BE; + + // GL_SGIX_texture_coordinate_clamp + GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369; + GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A; + GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B; + + // GL_SGIX_texture_lod_bias + GL_TEXTURE_LOD_BIAS_S_SGIX = $818E; + GL_TEXTURE_LOD_BIAS_T_SGIX = $818F; + GL_TEXTURE_LOD_BIAS_R_SGIX = $8190; + + // GL_SGIX_texture_multi_buffer + GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E; + + // GL_SGIX_texture_scale_bias + GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179; + GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A; + GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B; + GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C; + + // GL_SGIX_vertex_preclip + GL_VERTEX_PRECLIP_SGIX = $83EE; + GL_VERTEX_PRECLIP_HINT_SGIX = $83EF; + + // GL_SGIX_ycrcb + GL_YCRCB_422_SGIX = $81BB; + GL_YCRCB_444_SGIX = $81BC; + + // GL_SGIX_ycrcba + GL_YCRCB_SGIX = $8318; + GL_YCRCBA_SGIX = $8319; + + // GL_SGI_color_matrix + GL_COLOR_MATRIX_SGI = $80B1; + GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2; + GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3; + GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4; + GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5; + GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6; + GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7; + GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8; + GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9; + GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA; + GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB; + + // GL_SGI_color_table + GL_COLOR_TABLE_SGI = $80D0; + GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1; + GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2; + GL_PROXY_COLOR_TABLE_SGI = $80D3; + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4; + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5; + GL_COLOR_TABLE_SCALE_SGI = $80D6; + GL_COLOR_TABLE_BIAS_SGI = $80D7; + GL_COLOR_TABLE_FORMAT_SGI = $80D8; + GL_COLOR_TABLE_WIDTH_SGI = $80D9; + GL_COLOR_TABLE_RED_SIZE_SGI = $80DA; + GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB; + GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF; + + // GL_SGI_depth_pass_instrument + GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310; + GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311; + GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312; + + // GL_SGI_texture_color_table + GL_TEXTURE_COLOR_TABLE_SGI = $80BC; + GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD; + + // GL_SUNX_constant_data + GL_UNPACK_CONSTANT_DATA_SUNX = $81D5; + GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6; + + // GL_SUN_convolution_border_modes + GL_WRAP_BORDER_SUN = $81D4; + + // GL_SUN_global_alpha + GL_GLOBAL_ALPHA_SUN = $81D9; + GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA; + + // GL_SUN_mesh_array + GL_QUAD_MESH_SUN = $8614; + GL_TRIANGLE_MESH_SUN = $8615; + + // GL_SUN_slice_accum + GL_SLICE_ACCUM_SUN = $85CC; + + // GL_SUN_triangle_list + GL_RESTART_SUN = $0001; + GL_REPLACE_MIDDLE_SUN = $0002; + GL_REPLACE_OLDEST_SUN = $0003; + GL_TRIANGLE_LIST_SUN = $81D7; + GL_REPLACEMENT_CODE_SUN = $81D8; + GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0; + GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1; + GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2; + GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3; + GL_R1UI_V3F_SUN = $85C4; + GL_R1UI_C4UB_V3F_SUN = $85C5; + GL_R1UI_C3F_V3F_SUN = $85C6; + GL_R1UI_N3F_V3F_SUN = $85C7; + GL_R1UI_C4F_N3F_V3F_SUN = $85C8; + GL_R1UI_T2F_V3F_SUN = $85C9; + GL_R1UI_T2F_N3F_V3F_SUN = $85CA; + GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB; + + // GL_WIN_phong_shading + GL_PHONG_WIN = $80EA; + GL_PHONG_HINT_WIN = $80EB; + + // GL_WIN_specular_fog + GL_FOG_SPECULAR_TEXTURE_WIN = $80EC; + + // GL_ARB_vertex_shader + GL_VERTEX_SHADER_ARB = $8B31; + GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A; + GL_MAX_VARYING_FLOATS_ARB = $8B4B; + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D; + GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89; + GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A; + + // GL_KHR_blend_equation_advanced + GL_MULTIPLY_KHR = $9294; + GL_SCREEN_KHR = $9295; + GL_OVERLAY_KHR = $9296; + GL_DARKEN_KHR = $9297; + GL_LIGHTEN_KHR = $9298; + GL_COLORDODGE_KHR = $9299; + GL_COLORBURN_KHR = $929A; + GL_HARDLIGHT_KHR = $929B; + GL_SOFTLIGHT_KHR = $929C; + GL_DIFFERENCE_KHR = $929E; + GL_EXCLUSION_KHR = $92A0; + GL_HSL_HUE_KHR = $92AD; + GL_HSL_SATURATION_KHR = $92AE; + GL_HSL_COLOR_KHR = $92AF; + GL_HSL_LUMINOSITY_KHR = $92B0; + + // GL_KHR_blend_equation_advanced_coherent + GL_BLEND_ADVANCED_COHERENT_KHR = $9285; + + // GL_KHR_robustness + GL_CONTEXT_ROBUST_ACCESS = $90F3; + + // GL_ARB_fragment_shader + GL_FRAGMENT_SHADER_ARB = $8B30; + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4 + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4 + + // GL_ARB_occlusion_query + GL_SAMPLES_PASSED_ARB = $8914; + GL_QUERY_COUNTER_BITS_ARB = $8864; + GL_CURRENT_QUERY_ARB = $8865; + GL_QUERY_RESULT_ARB = $8866; + GL_QUERY_RESULT_AVAILABLE_ARB = $8867; + + // GL_ARB_pipeline_statistics_query + GL_VERTICES_SUBMITTED_ARB = $82EE; + GL_PRIMITIVES_SUBMITTED_ARB = $82EF; + GL_VERTEX_SHADER_INVOCATIONS_ARB = $82F0; + GL_TESS_CONTROL_SHADER_PATCHES_ARB = $82F1; + GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = $82F2; + GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = $82F3; + GL_FRAGMENT_SHADER_INVOCATIONS_ARB = $82F4; + GL_COMPUTE_SHADER_INVOCATIONS_ARB = $82F5; + GL_CLIPPING_INPUT_PRIMITIVES_ARB = $82F6; + GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = $82F7; + + // GL_ARB_point_sprite + GL_POINT_SPRITE_ARB = $8861; + GL_COORD_REPLACE_ARB = $8862; + + // GL_ARB_shading_language_100 + GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4 + + // GL_ARB_shader_objects + GL_PROGRAM_OBJECT_ARB = $8B40; + + GL_OBJECT_TYPE_ARB = $8B4E; + GL_OBJECT_SUBTYPE_ARB = $8B4F; + GL_OBJECT_DELETE_STATUS_ARB = $8B80; + GL_OBJECT_COMPILE_STATUS_ARB = $8B81; + GL_OBJECT_LINK_STATUS_ARB = $8B82; + GL_OBJECT_VALIDATE_STATUS_ARB = $8B83; + GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84; + GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85; + GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86; + GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87; + GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88; + + GL_SHADER_OBJECT_ARB = $8B48; + + GL_FLOAT_VEC2_ARB = $8B50; + GL_FLOAT_VEC3_ARB = $8B51; + GL_FLOAT_VEC4_ARB = $8B52; + GL_INT_VEC2_ARB = $8B53; + GL_INT_VEC3_ARB = $8B54; + GL_INT_VEC4_ARB = $8B55; + GL_BOOL_ARB = $8B56; + GL_BOOL_VEC2_ARB = $8B57; + GL_BOOL_VEC3_ARB = $8B58; + GL_BOOL_VEC4_ARB = $8B59; + GL_FLOAT_MAT2_ARB = $8B5A; + GL_FLOAT_MAT3_ARB = $8B5B; + GL_FLOAT_MAT4_ARB = $8B5C; + GL_SAMPLER_1D_ARB = $8B5D; + GL_SAMPLER_2D_ARB = $8B5E; + GL_SAMPLER_3D_ARB = $8B5F; + GL_SAMPLER_CUBE_ARB = $8B60; + GL_SAMPLER_1D_SHADOW_ARB = $8B61; + GL_SAMPLER_2D_SHADOW_ARB = $8B62; + GL_SAMPLER_2D_RECT_ARB = $8B63; + GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64; + + // WGL_3DFX_multisample + WGL_SAMPLE_BUFFERS_3DFX = $2060; + WGL_SAMPLES_3DFX = $2061; + + // WGL_ARB_buffer_region + WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001; + WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002; + WGL_DEPTH_BUFFER_BIT_ARB = $00000004; + WGL_STENCIL_BUFFER_BIT_ARB = $00000008; + + // WGL_ARB_context_flush_control + WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097; + WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0; + WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098; + + // WGL_ARB_make_current_read + ERROR_INVALID_PIXEL_TYPE_ARB = $2043; + ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054; + + // WGL_ARB_multisample + WGL_SAMPLE_BUFFERS_ARB = $2041; + WGL_SAMPLES_ARB = $2042; + + // WGL_ARB_pbuffer + WGL_DRAW_TO_PBUFFER_ARB = $202D; + WGL_MAX_PBUFFER_PIXELS_ARB = $202E; + WGL_MAX_PBUFFER_WIDTH_ARB = $202F; + WGL_MAX_PBUFFER_HEIGHT_ARB = $2030; + WGL_PBUFFER_LARGEST_ARB = $2033; + WGL_PBUFFER_WIDTH_ARB = $2034; + WGL_PBUFFER_HEIGHT_ARB = $2035; + WGL_PBUFFER_LOST_ARB = $2036; + + // WGL_ARB_pixel_format + WGL_NUMBER_PIXEL_FORMATS_ARB = $2000; + WGL_DRAW_TO_WINDOW_ARB = $2001; + WGL_DRAW_TO_BITMAP_ARB = $2002; + WGL_ACCELERATION_ARB = $2003; + WGL_NEED_PALETTE_ARB = $2004; + WGL_NEED_SYSTEM_PALETTE_ARB = $2005; + WGL_SWAP_LAYER_BUFFERS_ARB = $2006; + WGL_SWAP_METHOD_ARB = $2007; + WGL_NUMBER_OVERLAYS_ARB = $2008; + WGL_NUMBER_UNDERLAYS_ARB = $2009; + WGL_TRANSPARENT_ARB = $200A; + WGL_TRANSPARENT_RED_VALUE_ARB = $2037; + WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038; + WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039; + WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A; + WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B; + WGL_SHARE_DEPTH_ARB = $200C; + WGL_SHARE_STENCIL_ARB = $200D; + WGL_SHARE_ACCUM_ARB = $200E; + WGL_SUPPORT_GDI_ARB = $200F; + WGL_SUPPORT_OPENGL_ARB = $2010; + WGL_DOUBLE_BUFFER_ARB = $2011; + WGL_STEREO_ARB = $2012; + WGL_PIXEL_TYPE_ARB = $2013; + WGL_COLOR_BITS_ARB = $2014; + WGL_RED_BITS_ARB = $2015; + WGL_RED_SHIFT_ARB = $2016; + WGL_GREEN_BITS_ARB = $2017; + WGL_GREEN_SHIFT_ARB = $2018; + WGL_BLUE_BITS_ARB = $2019; + WGL_BLUE_SHIFT_ARB = $201A; + WGL_ALPHA_BITS_ARB = $201B; + WGL_ALPHA_SHIFT_ARB = $201C; + WGL_ACCUM_BITS_ARB = $201D; + WGL_ACCUM_RED_BITS_ARB = $201E; + WGL_ACCUM_GREEN_BITS_ARB = $201F; + WGL_ACCUM_BLUE_BITS_ARB = $2020; + WGL_ACCUM_ALPHA_BITS_ARB = $2021; + WGL_DEPTH_BITS_ARB = $2022; + WGL_STENCIL_BITS_ARB = $2023; + WGL_AUX_BUFFERS_ARB = $2024; + WGL_NO_ACCELERATION_ARB = $2025; + WGL_GENERIC_ACCELERATION_ARB = $2026; + WGL_FULL_ACCELERATION_ARB = $2027; + WGL_SWAP_EXCHANGE_ARB = $2028; + WGL_SWAP_COPY_ARB = $2029; + WGL_SWAP_UNDEFINED_ARB = $202A; + WGL_TYPE_RGBA_ARB = $202B; + WGL_TYPE_COLORINDEX_ARB = $202C; + + // WGL_ARB_pixel_format_float + WGL_RGBA_FLOAT_MODE_ARB = $8820; + WGL_CLAMP_VERTEX_COLOR_ARB = $891A; + WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B; + WGL_CLAMP_READ_COLOR_ARB = $891C; + WGL_FIXED_ONLY_ARB = $891D; + + // WGL_ARB_render_texture + WGL_BIND_TO_TEXTURE_RGB_ARB = $2070; + WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071; + WGL_TEXTURE_FORMAT_ARB = $2072; + WGL_TEXTURE_TARGET_ARB = $2073; + WGL_MIPMAP_TEXTURE_ARB = $2074; + WGL_TEXTURE_RGB_ARB = $2075; + WGL_TEXTURE_RGBA_ARB = $2076; + WGL_NO_TEXTURE_ARB = $2077; + WGL_TEXTURE_CUBE_MAP_ARB = $2078; + WGL_TEXTURE_1D_ARB = $2079; + WGL_TEXTURE_2D_ARB = $207A; + WGL_MIPMAP_LEVEL_ARB = $207B; + WGL_CUBE_MAP_FACE_ARB = $207C; + WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E; + WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080; + WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082; + WGL_FRONT_LEFT_ARB = $2083; + WGL_FRONT_RIGHT_ARB = $2084; + WGL_BACK_LEFT_ARB = $2085; + WGL_BACK_RIGHT_ARB = $2086; + WGL_AUX0_ARB = $2087; + WGL_AUX1_ARB = $2088; + WGL_AUX2_ARB = $2089; + WGL_AUX3_ARB = $208A; + WGL_AUX4_ARB = $208B; + WGL_AUX5_ARB = $208C; + WGL_AUX6_ARB = $208D; + WGL_AUX7_ARB = $208E; + WGL_AUX8_ARB = $208F; + WGL_AUX9_ARB = $2090; + + // WGL_ARB_robustness_application_isolation + WGL_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008; + + // WGL_ARB_create_context + WGL_CONTEXT_DEBUG_BIT_ARB = $00000001; + WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; + WGL_CONTEXT_MAJOR_VERSION_ARB = $2091; + WGL_CONTEXT_MINOR_VERSION_ARB = $2092; + WGL_CONTEXT_LAYER_PLANE_ARB = $2093; + WGL_CONTEXT_FLAGS_ARB = $2094; + ERROR_INVALID_VERSION_ARB = $2095; + + // WGL_ARB_create_context_profile + WGL_CONTEXT_PROFILE_MASK_ARB = $9126; + WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; + WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; + ERROR_INVALID_PROFILE_ARB = $2096; + + // WGL_ARB_framebuffer_sRGB + WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20A9; + + // WGL_ARB_create_context_robustness + WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; + WGL_LOSE_CONTEXT_ON_RESET_ARB = $8252; + WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + WGL_NO_RESET_NOTIFICATION_ARB = $8261; + + // WGL_ATI_pixel_format_float + WGL_TYPE_RGBA_FLOAT_ATI = $21A0; + GL_TYPE_RGBA_FLOAT_ATI = $8820; + GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835; + + // WGL_AMD_gpu_association + WGL_GPU_VENDOR_AMD = $1F00; + WGL_GPU_RENDERER_STRING_AMD = $1F01; + WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02; + WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2; + WGL_GPU_RAM_AMD = $21A3; + WGL_GPU_CLOCK_AMD = $21A4; + WGL_GPU_NUM_PIPES_AMD = $21A5; + WGL_GPU_NUM_SIMD_AMD = $21A6; + WGL_GPU_NUM_RB_AMD = $21A7; + WGL_GPU_NUM_SPI_AMD = $21A8; + + // WGL_EXT_depth_float + WGL_DEPTH_FLOAT_EXT = $2040; + + // WGL_EXT_make_current_read + ERROR_INVALID_PIXEL_TYPE_EXT = $2043; + + // WGL_EXT_multisample + WGL_SAMPLE_BUFFERS_EXT = $2041; + WGL_SAMPLES_EXT = $2042; + + // WGL_EXT_pbuffer + WGL_DRAW_TO_PBUFFER_EXT = $202D; + WGL_MAX_PBUFFER_PIXELS_EXT = $202E; + WGL_MAX_PBUFFER_WIDTH_EXT = $202F; + WGL_MAX_PBUFFER_HEIGHT_EXT = $2030; + WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031; + WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032; + WGL_PBUFFER_LARGEST_EXT = $2033; + WGL_PBUFFER_WIDTH_EXT = $2034; + WGL_PBUFFER_HEIGHT_EXT = $2035; + + // WGL_EXT_pixel_format + WGL_NUMBER_PIXEL_FORMATS_EXT = $2000; + WGL_DRAW_TO_WINDOW_EXT = $2001; + WGL_DRAW_TO_BITMAP_EXT = $2002; + WGL_ACCELERATION_EXT = $2003; + WGL_NEED_PALETTE_EXT = $2004; + WGL_NEED_SYSTEM_PALETTE_EXT = $2005; + WGL_SWAP_LAYER_BUFFERS_EXT = $2006; + WGL_SWAP_METHOD_EXT = $2007; + WGL_NUMBER_OVERLAYS_EXT = $2008; + WGL_NUMBER_UNDERLAYS_EXT = $2009; + WGL_TRANSPARENT_EXT = $200A; + WGL_TRANSPARENT_VALUE_EXT = $200B; + WGL_SHARE_DEPTH_EXT = $200C; + WGL_SHARE_STENCIL_EXT = $200D; + WGL_SHARE_ACCUM_EXT = $200E; + WGL_SUPPORT_GDI_EXT = $200F; + WGL_SUPPORT_OPENGL_EXT = $2010; + WGL_DOUBLE_BUFFER_EXT = $2011; + WGL_STEREO_EXT = $2012; + WGL_PIXEL_TYPE_EXT = $2013; + WGL_COLOR_BITS_EXT = $2014; + WGL_RED_BITS_EXT = $2015; + WGL_RED_SHIFT_EXT = $2016; + WGL_GREEN_BITS_EXT = $2017; + WGL_GREEN_SHIFT_EXT = $2018; + WGL_BLUE_BITS_EXT = $2019; + WGL_BLUE_SHIFT_EXT = $201A; + WGL_ALPHA_BITS_EXT = $201B; + WGL_ALPHA_SHIFT_EXT = $201C; + WGL_ACCUM_BITS_EXT = $201D; + WGL_ACCUM_RED_BITS_EXT = $201E; + WGL_ACCUM_GREEN_BITS_EXT = $201F; + WGL_ACCUM_BLUE_BITS_EXT = $2020; + WGL_ACCUM_ALPHA_BITS_EXT = $2021; + WGL_DEPTH_BITS_EXT = $2022; + WGL_STENCIL_BITS_EXT = $2023; + WGL_AUX_BUFFERS_EXT = $2024; + WGL_NO_ACCELERATION_EXT = $2025; + WGL_GENERIC_ACCELERATION_EXT = $2026; + WGL_FULL_ACCELERATION_EXT = $2027; + WGL_SWAP_EXCHANGE_EXT = $2028; + WGL_SWAP_COPY_EXT = $2029; + WGL_SWAP_UNDEFINED_EXT = $202A; + WGL_TYPE_RGBA_EXT = $202B; + WGL_TYPE_COLORINDEX_EXT = $202C; + + // WGL_I3D_digital_video_control + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050; + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051; + WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052; + WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053; + + // WGL_I3D_gamma + WGL_GAMMA_TABLE_SIZE_I3D = $204E; + WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F; + + // WGL_I3D_genlock + WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044; + WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045; + WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046; + WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047; + WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048; + WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049; + WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A; + WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B; + WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C; + + // WGL_I3D_image_buffer + WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001; + WGL_IMAGE_BUFFER_LOCK_I3D = $00000002; + + // WGL_NV_float_buffer + WGL_FLOAT_COMPONENTS_NV = $20B0; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4; + WGL_TEXTURE_FLOAT_R_NV = $20B5; + WGL_TEXTURE_FLOAT_RG_NV = $20B6; + WGL_TEXTURE_FLOAT_RGB_NV = $20B7; + WGL_TEXTURE_FLOAT_RGBA_NV = $20B8; + + // WGL_NV_render_depth_texture + WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3; + WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4; + WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5; + WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6; + WGL_DEPTH_COMPONENT_NV = $20A7; + + // WGL_NV_render_texture_rectangle + WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0; + WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1; + WGL_TEXTURE_RECTANGLE_NV = $20A2; + + // WGL_NV_present_video + WGL_NUM_VIDEO_SLOTS_NV = $20F0; + + // WGL_NV_video_output + WGL_BIND_TO_VIDEO_RGB_NV = $20C0; + WGL_BIND_TO_VIDEO_RGBA_NV = $20C1; + WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2; + WGL_VIDEO_OUT_COLOR_NV = $20C3; + WGL_VIDEO_OUT_ALPHA_NV = $20C4; + WGL_VIDEO_OUT_DEPTH_NV = $20C5; + WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6; + WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7; + WGL_VIDEO_OUT_FRAME = $20C8; + WGL_VIDEO_OUT_FIELD_1 = $20C9; + WGL_VIDEO_OUT_FIELD_2 = $20CA; + WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB; + WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC; + + // WGL_NV_gpu_affinity + WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0; + WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1; + + // WGL_NV_video_capture + WGL_UNIQUE_ID_NV = $20CE; + WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = $20CF; + + // WGL_NV_multisample_coverage + WGL_COVERAGE_SAMPLES_NV = $2042; + WGL_COLOR_SAMPLES_NV = $20B9; + + // WGL_EXT_create_context_es2_profile + WGL_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; + + // WGL_NV_DX_interop + WGL_ACCESS_READ_ONLY_NV = $00000000; + WGL_ACCESS_READ_WRITE_NV = $00000001; + WGL_ACCESS_WRITE_DISCARD_NV = $00000002; + + // WIN_draw_range_elements + GL_MAX_ELEMENTS_VERTICES_WIN = $80E8; + GL_MAX_ELEMENTS_INDICES_WIN = $80E9; + + // GLX 1.1 and later: + GLX_VENDOR = 1; + GLX_VERSION = 2; + GLX_EXTENSIONS = 3; + + GLX_USE_GL = 1; + GLX_BUFFER_SIZE = 2; + GLX_LEVEL = 3; + GLX_RGBA = 4; + GLX_DOUBLEBUFFER = 5; + GLX_STEREO = 6; + GLX_AUX_BUFFERS = 7; + GLX_RED_SIZE = 8; + GLX_GREEN_SIZE = 9; + GLX_BLUE_SIZE = 10; + GLX_ALPHA_SIZE = 11; + GLX_DEPTH_SIZE = 12; + GLX_STENCIL_SIZE = 13; + GLX_ACCUM_RED_SIZE = 14; + GLX_ACCUM_GREEN_SIZE = 15; + GLX_ACCUM_BLUE_SIZE = 16; + GLX_ACCUM_ALPHA_SIZE = 17; + + // GLX_VERSION_1_3 + GLX_WINDOW_BIT = $00000001; + GLX_PIXMAP_BIT = $00000002; + GLX_PBUFFER_BIT = $00000004; + GLX_RGBA_BIT = $00000001; + GLX_COLOR_INDEX_BIT = $00000002; + GLX_PBUFFER_CLOBBER_MASK = $08000000; + GLX_FRONT_LEFT_BUFFER_BIT = $00000001; + GLX_FRONT_RIGHT_BUFFER_BIT = $00000002; + GLX_BACK_LEFT_BUFFER_BIT = $00000004; + GLX_BACK_RIGHT_BUFFER_BIT = $00000008; + GLX_AUX_BUFFERS_BIT = $00000010; + GLX_DEPTH_BUFFER_BIT = $00000020; + GLX_STENCIL_BUFFER_BIT = $00000040; + GLX_ACCUM_BUFFER_BIT = $00000080; + GLX_CONFIG_CAVEAT = $20; + GLX_X_VISUAL_TYPE = $22; + GLX_TRANSPARENT_TYPE = $23; + GLX_TRANSPARENT_INDEX_VALUE = $24; + GLX_TRANSPARENT_RED_VALUE = $25; + GLX_TRANSPARENT_GREEN_VALUE = $26; + GLX_TRANSPARENT_BLUE_VALUE = $27; + GLX_TRANSPARENT_ALPHA_VALUE = $28; + GLX_DONT_CARE = $FFFFFFFF; + GLX_NONE = $8000; + GLX_SLOW_CONFIG = $8001; + GLX_TRUE_COLOR = $8002; + GLX_DIRECT_COLOR = $8003; + GLX_PSEUDO_COLOR = $8004; + GLX_STATIC_COLOR = $8005; + GLX_GRAY_SCALE = $8006; + GLX_STATIC_GRAY = $8007; + GLX_TRANSPARENT_RGB = $8008; + GLX_TRANSPARENT_INDEX = $8009; + GLX_VISUAL_ID = $800B; + GLX_SCREEN = $800C; + GLX_NON_CONFORMANT_CONFIG = $800D; + GLX_DRAWABLE_TYPE = $8010; + GLX_RENDER_TYPE = $8011; + GLX_X_RENDERABLE = $8012; + GLX_FBCONFIG_ID = $8013; + GLX_RGBA_TYPE = $8014; + GLX_COLOR_INDEX_TYPE = $8015; + GLX_MAX_PBUFFER_WIDTH = $8016; + GLX_MAX_PBUFFER_HEIGHT = $8017; + GLX_MAX_PBUFFER_PIXELS = $8018; + GLX_PRESERVED_CONTENTS = $801B; + GLX_LARGEST_PBUFFER = $801C; + GLX_WIDTH = $801D; + GLX_HEIGHT = $801E; + GLX_EVENT_MASK = $801F; + GLX_DAMAGED = $8020; + GLX_SAVED = $8021; + GLX_WINDOW = $8022; + GLX_PBUFFER = $8023; + GLX_PBUFFER_HEIGHT = $8040; + GLX_PBUFFER_WIDTH = $8041; + + // GLX_VERSION_1_4 + GLX_SAMPLE_BUFFERS = 100000; + GLX_SAMPLES = 100001; + + // GLX_ARB_multisample + GLX_SAMPLE_BUFFERS_ARB = 100000; + GLX_SAMPLES_ARB = 100001; + + // GLX_ARB_robustness_application_isolation + GLX_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008; + + // GLX_ARB_fbconfig_float + GLX_RGBA_FLOAT_TYPE_ARB = $20B9; + GLX_RGBA_FLOAT_BIT_ARB = $00000004; + + // GLX_ARB_context_flush_control + GLX_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097; + GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0; + GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098; + + // GLX_ARB_create_context + GLX_CONTEXT_DEBUG_BIT_ARB = $00000001; + GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; + GLX_CONTEXT_MAJOR_VERSION_ARB = $2091; + GLX_CONTEXT_MINOR_VERSION_ARB = $2092; + GLX_CONTEXT_FLAGS_ARB = $2094; + + // GLX_ARB_create_context_profile + GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; + GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; + GLX_CONTEXT_PROFILE_MASK_ARB = $9126; + + // GLX_ARB_vertex_buffer_object + GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = $2095; + + // GLX_ARB_framebuffer_sRGB + GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20B2; + + // GLX_ARB_create_context_robustness + GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; + GLX_LOSE_CONTEXT_ON_RESET_ARB = $8252; + GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + GLX_NO_RESET_NOTIFICATION_ARB = $8261; + + // GLX_EXT_visual_info + GLX_X_VISUAL_TYPE_EXT = $22; + GLX_TRANSPARENT_TYPE_EXT = $23; + GLX_TRANSPARENT_INDEX_VALUE_EXT = $24; + GLX_TRANSPARENT_RED_VALUE_EXT = $25; + GLX_TRANSPARENT_GREEN_VALUE_EXT = $26; + GLX_TRANSPARENT_BLUE_VALUE_EXT = $27; + GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28; + GLX_NONE_EXT = $8000; + GLX_TRUE_COLOR_EXT = $8002; + GLX_DIRECT_COLOR_EXT = $8003; + GLX_PSEUDO_COLOR_EXT = $8004; + GLX_STATIC_COLOR_EXT = $8005; + GLX_GRAY_SCALE_EXT = $8006; + GLX_STATIC_GRAY_EXT = $8007; + GLX_TRANSPARENT_RGB_EXT = $8008; + GLX_TRANSPARENT_INDEX_EXT = $8009; + + // GLX_EXT_visual_rating + GLX_VISUAL_CAVEAT_EXT = $20; + GLX_SLOW_VISUAL_EXT = $8001; + GLX_NON_CONFORMANT_VISUAL_EXT = $800D; + (* reuse GLX_NONE_EXT *) + + // GLX_EXT_import_context + GLX_SHARE_CONTEXT_EXT = $800A; + GLX_VISUAL_ID_EXT = $800B; + GLX_SCREEN_EXT = $800C; + + // GLX_EXT_fbconfig_packed_float +// GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; +// GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; + + // GLX_EXT_framebuffer_sRGB +// GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; + + // GLX_EXT_texture_from_pixmap + GLX_TEXTURE_1D_BIT_EXT = $00000001; + GLX_TEXTURE_2D_BIT_EXT = $00000002; + GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004; + GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0; + GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1; + GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2; + GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3; + GLX_Y_INVERTED_EXT = $20D4; + GLX_TEXTURE_FORMAT_EXT = $20D5; + GLX_TEXTURE_TARGET_EXT = $20D6; + GLX_MIPMAP_TEXTURE_EXT = $20D7; + GLX_TEXTURE_FORMAT_NONE_EXT = $20D8; + GLX_TEXTURE_FORMAT_RGB_EXT = $20D9; + GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA; + GLX_TEXTURE_1D_EXT = $20DB; + GLX_TEXTURE_2D_EXT = $20DC; + GLX_TEXTURE_RECTANGLE_EXT = $20DD; + GLX_FRONT_LEFT_EXT = $20DE; + GLX_FRONT_RIGHT_EXT = $20DF; + GLX_BACK_LEFT_EXT = $20E0; + GLX_BACK_RIGHT_EXT = $20E1; + GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT; + GLX_BACK_EXT = GLX_BACK_LEFT_EXT; + GLX_AUX0_EXT = $20E2; + GLX_AUX1_EXT = $20E3; + GLX_AUX2_EXT = $20E4; + GLX_AUX3_EXT = $20E5; + GLX_AUX4_EXT = $20E6; + GLX_AUX5_EXT = $20E7; + GLX_AUX6_EXT = $20E8; + GLX_AUX7_EXT = $20E9; + GLX_AUX8_EXT = $20EA; + GLX_AUX9_EXT = $20EB; + + // GLX_EXT_swap_control + GLX_SWAP_INTERVAL_EXT = $20F1; + GLX_MAX_SWAP_INTERVAL_EXT = $20F2; + + // GLX_EXT_create_context_es2_profile + GLX_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; + + // GL_EXT_Late_Swaps + GLX_LATE_SWAPS_TEAR_EXT = $20F3; + + // GLU + GLU_INVALID_ENUM = 100900; + GLU_INVALID_VALUE = 100901; + GLU_OUT_OF_MEMORY = 100902; + GLU_INCOMPATIBLE_GL_VERSION = 100903; + GLU_VERSION = 100800; + GLU_EXTENSIONS = 100801; + GLU_TRUE: ByteBool = True; + GLU_FALSE: ByteBool = False; + GLU_SMOOTH = 100000; + GLU_FLAT = 100001; + GLU_NONE = 100002; + GLU_POINT = 100010; + GLU_LINE = 100011; + GLU_FILL = 100012; + GLU_SILHOUETTE = 100013; + GLU_OUTSIDE = 100020; + GLU_INSIDE = 100021; + GLU_TESS_MAX_COORD = 1.0E150; + GLU_TESS_WINDING_RULE = 100140; + GLU_TESS_BOUNDARY_ONLY = 100141; + GLU_TESS_TOLERANCE = 100142; + GLU_TESS_WINDING_ODD = 100130; + GLU_TESS_WINDING_NONZERO = 100131; + GLU_TESS_WINDING_POSITIVE = 100132; + GLU_TESS_WINDING_NEGATIVE = 100133; + GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; + GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc + GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc + GLU_TESS_END = 100102; // TGLUTessEndProc + GLU_TESS_ERROR = 100103; // TGLUTessErrorProc + GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc + GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc + GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc + GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc + GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc + GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc + GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc + GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc + GLU_TESS_ERROR1 = 100151; + GLU_TESS_ERROR2 = 100152; + GLU_TESS_ERROR3 = 100153; + GLU_TESS_ERROR4 = 100154; + GLU_TESS_ERROR5 = 100155; + GLU_TESS_ERROR6 = 100156; + GLU_TESS_ERROR7 = 100157; + GLU_TESS_ERROR8 = 100158; + GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1; + GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2; + GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3; + GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4; + GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5; + GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6; + GLU_AUTO_LOAD_MATRIX = 100200; + GLU_CULLING = 100201; + GLU_SAMPLING_TOLERANCE = 100203; + GLU_DISPLAY_MODE = 100204; + GLU_PARAMETRIC_TOLERANCE = 100202; + GLU_SAMPLING_METHOD = 100205; + GLU_U_STEP = 100206; + GLU_V_STEP = 100207; + GLU_PATH_LENGTH = 100215; + GLU_PARAMETRIC_ERROR = 100216; + GLU_DOMAIN_DISTANCE = 100217; + GLU_MAP1_TRIM_2 = 100210; + GLU_MAP1_TRIM_3 = 100211; + GLU_OUTLINE_POLYGON = 100240; + GLU_OUTLINE_PATCH = 100241; + GLU_NURBS_ERROR1 = 100251; + GLU_NURBS_ERROR2 = 100252; + GLU_NURBS_ERROR3 = 100253; + GLU_NURBS_ERROR4 = 100254; + GLU_NURBS_ERROR5 = 100255; + GLU_NURBS_ERROR6 = 100256; + GLU_NURBS_ERROR7 = 100257; + GLU_NURBS_ERROR8 = 100258; + GLU_NURBS_ERROR9 = 100259; + GLU_NURBS_ERROR10 = 100260; + GLU_NURBS_ERROR11 = 100261; + GLU_NURBS_ERROR12 = 100262; + GLU_NURBS_ERROR13 = 100263; + GLU_NURBS_ERROR14 = 100264; + GLU_NURBS_ERROR15 = 100265; + GLU_NURBS_ERROR16 = 100266; + GLU_NURBS_ERROR17 = 100267; + GLU_NURBS_ERROR18 = 100268; + GLU_NURBS_ERROR19 = 100269; + GLU_NURBS_ERROR20 = 100270; + GLU_NURBS_ERROR21 = 100271; + GLU_NURBS_ERROR22 = 100272; + GLU_NURBS_ERROR23 = 100273; + GLU_NURBS_ERROR24 = 100274; + GLU_NURBS_ERROR25 = 100275; + GLU_NURBS_ERROR26 = 100276; + GLU_NURBS_ERROR27 = 100277; + GLU_NURBS_ERROR28 = 100278; + GLU_NURBS_ERROR29 = 100279; + GLU_NURBS_ERROR30 = 100280; + GLU_NURBS_ERROR31 = 100281; + GLU_NURBS_ERROR32 = 100282; + GLU_NURBS_ERROR33 = 100283; + GLU_NURBS_ERROR34 = 100284; + GLU_NURBS_ERROR35 = 100285; + GLU_NURBS_ERROR36 = 100286; + GLU_NURBS_ERROR37 = 100287; + GLU_CW = 100120; + GLU_CCW = 100121; + GLU_INTERIOR = 100122; + GLU_EXTERIOR = 100123; + GLU_UNKNOWN = 100124; + GLU_BEGIN = GLU_TESS_BEGIN; + GLU_VERTEX = GLU_TESS_VERTEX; + GLU_END = GLU_TESS_END; + GLU_ERROR = GLU_TESS_ERROR; + GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG; + +type + // GL_VERSION_1_2 + TglBlendColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquation = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElements = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTable = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorTable = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTable = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorSubTable = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorSubTable = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterf = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameteri = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSeparableFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSeparableFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogram = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmax = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglHistogram = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMinmax = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetHistogram = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetMinmax = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_1_3 + TglActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleCoverage = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClientActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1d = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1f = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1i = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1s = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2d = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2f = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2i = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2s = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_1_4 + TglBlendFuncSeparate = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawArrays = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElements = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameteri = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameteriv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordf = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordd = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_1_5 + TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffer = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteBuffers = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenBuffers = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsBuffer = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferData = procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapBuffer = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapBuffer = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferPointerv = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_2_0 + TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFuncSeparate = procedure(face: GLenum; func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveAttrib = procedure(programObj: GLhandle; index: GLuint; maxlength: GLsizei; var length: GLint; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniform = procedure(programObj: GLhandle; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttribLocation = function(programObj: GLhandle; char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramiv = procedure(programObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; length: PGLSizei; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; length: PGLSizei; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgram = function(programObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsShader = function(shaderObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; const _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_2_1 + TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_3_0 + { OpenGL 3.0 also reuses entry points from these extensions: } + { ARB_framebuffer_object } + { ARB_map_buffer_range } + { ARB_vertex_array_object } + TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GL_VERSION_2_1 + TglEnableVertexArrayEXT = procedure(vaobj: GLuint; array_: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexArrayAttribEXT = procedure(vaobj: GLuint; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; normalized: GLboolean; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_1 + { OpenGL 3.1 also reuses entry points from these extensions: } + { ARB_copy_buffer } + { ARB_uniform_buffer_object } + TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_2 + { OpenGL 3.2 also reuses entry points from these extensions: } + { ARB_draw_elements_base_vertex } + { ARB_provoking_vertex } + { ARB_sync } + { ARB_texture_multisample } + TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +// TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_3 + { OpenGL 3.3 also reuses entry points from these extensions: } + { ARB_blend_func_extended } + { ARB_sampler_objects } + { ARB_explicit_attrib_location, but it has none } + { ARB_occlusion_query2 (no entry points) } + { ARB_shader_bit_encoding (no entry points) } + { ARB_texture_rgb10_a2ui (no entry points) } + { ARB_texture_swizzle (no entry points) } + { ARB_timer_query } + { ARB_vertex_type_2_10_10_10_rev } + TglVertexAttribDivisor = procedure(index: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_4_0 + { OpenGL 4.0 also reuses entry points from these extensions: } + { ARB_texture_query_lod (no entry points) } + { ARB_draw_indirect } + { ARB_gpu_shader5 (no entry points) } + { ARB_gpu_shader_fp64 } + { ARB_shader_subroutine } + { ARB_tessellation_shader } + { ARB_texture_buffer_object_rgb32 (no entry points) } + { ARB_texture_cube_map_array (no entry points) } + { ARB_texture_gather (no entry points) } + { ARB_transform_feedback2 } + { ARB_transform_feedback3 } + TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_4_1 + { OpenGL 4.1 also reuses entry points from these extensions: } + { ARB_ES2_compatibility } + { ARB_get_program_binary } + { ARB_separate_shader_objects } + { ARB_shader_precision (no entry points) } + { ARB_vertex_attrib_64bit } + { ARB_viewport_array } + + // GL_ARB_framebuffer_object + TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_map_buffer_range + TglMapBufferRange = function(target: GLenum; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_array_object + TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_uniform_buffer_object + TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_copy_buffer + TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_elements_base_vertex + TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_provoking_vertex + TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_sync + TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_multisample + TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_blend_func_extended + TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_sampler_objects + TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_timer_query + TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_type_2_10_10_10_rev + TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_indirect + TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_gpu_shader_fp64 + TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shader_subroutine + TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_tessellation_shader + TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback2 + TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback3 + TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_ES2_compatibility + TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_get_program_binary + TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_separate_shader_objects + TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_attrib_64bit + TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_viewport_array + TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.2 + + // GL_ARB_base_instance + TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback_instanced + TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_internalformat_query + TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shader_atomic_counters + TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + /// GL_ARB_shader_image_load_store + TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_storage + TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.3 + // GL_ARB_clear_buffer_object + TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_compute_shader + TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_copy_image + TglCopyImageSubData = procedure(srcName : GLUInt; srcTarget : GLenum; srcLevel : GLint; srcX : GLint; srcY : GLint; srcZ : GLint; dstName : GLUInt; dstTarget : GLEnum; dstLevel : GLInt; dstX : GLInt; dstY : GLint; dstZ : GLint; srcWidth : GLsizei; srcHeight : GLsizei; srcDepth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_framebuffer_no_attachments + TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_internalformat_query2 + TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_invalidate_subdata + TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_multi_draw_indirect + TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_program_interface_query + TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_robust_buffer_access_behavior + + // GL_ARB_shader_image_size + + // GL_ARB_shader_storage_buffer_object + TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_stencil_texturing + + // GL_ARB_texture_buffer_range + TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_query_levels + + // GL_ARB_texture_storage_multisample + TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.4 + TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.5 + TglClipControl = procedure(origin : GLenum; depth : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateTransformFeedbacks = procedure(n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackBufferBase = procedure (xfb : GLuint; index : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackBufferRange = procedure (xfb : GLuint; index : GLuint; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbackiv = procedure (xfb : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbacki_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbacki64_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateBuffers = procedure (n : GLsizei; buffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedBufferStorage = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedBufferData = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; usage : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyNamedBufferSubData = procedure (readBuffer : GLuint; writeBuffer : GLuint; readOffset : GLintptr; writeOffset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedBufferData = procedure (buffer : GLuint; internalformat : GLenum; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedBufferSubData = procedure (buffer : GLuint; internalformat : GLenum; offset : GLintptr; size : GLsizei; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapNamedBuffer = function(buffer : GLuint; access : GLenum) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapNamedBufferRange = function(buffer : GLuint; offset : GLintptr; length : GLsizei; access : GLbitfield) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapNamedBuffer = function(buffer : GLuint) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushMappedNamedBufferRange = procedure (buffer : GLuint; offset : GLintptr; length : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferParameteriv = procedure (buffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferParameteri64v = procedure (buffer : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferPointerv = procedure (buffer : GLuint; pname : GLenum; params : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateFramebuffers = procedure (n : GLsizei; framebuffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferRenderbuffer = procedure (framebuffer : GLuint; attachment : GLenum ; renderbuffertarget : GLEnum; renderbuffer : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferParameteri = procedure (framebuffer : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTexture = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTextureLayer = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint; layer : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferDrawBuffer = procedure (framebuffer : GLuint; buf : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferDrawBuffers = procedure (framebuffer : GLuint; n : GLsizei; bufs : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferReadBuffer = procedure (framebuffer : GLuint; src : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateNamedFramebufferData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateNamedFramebufferSubData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedFramebufferiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedFramebufferuiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedFramebufferfv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedFramebufferfi = procedure (framebuffer : GLuint; buffer : GLenum; const depth : GLfloat; stencil : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlitNamedFramebuffer = procedure (readFramebuffer : GLuint; drawFramebuffer : GLuint; srcX0 : GLint; srcY0 : GLint; srcX1 : GLint; srcY1 : GLint; dstX0 : GLint; dstY0 : GLint; dstX1 : GLint; dstY1 : GLint ; mask : GLbitfield; filter : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCheckNamedFramebufferStatus = function(framebuffer : GLuint; target : GLenum) : GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedFramebufferParameteriv = procedure (framebuffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedFramebufferAttachmentParameteriv = procedure (framebuffer : GLuint; attachment : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateRenderbuffers = procedure (n : GLsizei; renderbuffers : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedRenderbufferStorage = procedure (renderbuffer : GLUInt; internalformat : GLenum ; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedRenderbufferStorageMultisample = procedure (renderbuffer : GLUInt; samples : GLSizei; internalformat : GLenum ; width : GLSizei; height : GLSizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedRenderbufferParameteriv = procedure (renderbuffer : GLUInt; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateTextures = procedure (target : GLenum ; n : GLsizei; textures : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureBuffer = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureBufferRange = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage1D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage2D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage3D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage2DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage3DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; mageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage1D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; x : GLint; y : GLint; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage2D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage3D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterf = procedure (texture : GLuint; pname : GLenum; param : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterfv = procedure (texture : GLuint; pname : GLenum; const param : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameteri = procedure (texture : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; const params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; const params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameteriv = procedure (texture : GLuint; pname : GLenum; const param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateTextureMipmap = procedure(texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTextureUnit = procedure (_unit : GLuint; texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureImage = procedure (texture : GLuint; level : GLint ; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTextureImage = procedure (texture : GLuint; level : GLint; bufSize : GLSizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureLevelParameterfv = procedure (texture : GLuint; level : GLint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureLevelParameteriv = procedure (texture : GLuint; level : GLint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterfv = procedure (texture : GLuint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; params : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameteriv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateVertexArrays = procedure (n : GLsizei; arrays : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayElementBuffer = procedure (vaobj : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexBuffer = procedure (vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexBuffers = procedure (vaobj : GLuint; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : PGLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayAttribBinding = procedure (vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayAttribFormat = procedure(vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; normalized : GLboolean; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayAttribIFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayAttribLFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayBindingDivisor = procedure (vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexArrayiv = procedure (vaobj : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexArrayIndexediv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexArrayIndexed64iv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateSamplers = procedure (n : GLsizei; samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateProgramPipelines = procedure (n : GLsizei; pipelines : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateQueries = procedure (target : GLenum; n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMemoryBarrierByRegion = procedure (barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetGraphicsResetStatus = function : GLEnum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnCompressedTexImage = procedure (target : GLenum; lod : GLint; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnTexImage = procedure (target : GLenum; level : GLint; format : GLenum; _type : GLenum; bufSize : GLSizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformdv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformfv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformuiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadnPixels = procedure (x : GLint; y : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapdv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapfv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapiv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapfv = procedure (map : GLenum; bufSize : GLsizei; values : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapuiv = procedure (map : GLenum; bufSize : GLsizei; values : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapusv = procedure (map : GLenum; bufSize : GLsizei; values : PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPolygonStipple = procedure (bufSize : GLsizei; pattern : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnColorTable = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; table : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnConvolutionFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; image : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnSeparableFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; rowBufSize : GLsizei; row : PGLvoid; columnBufSize : GLsizei; column : PGLvoid; span : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnHistogram = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMinmax = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureBarrier = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_view + TglTextureView = procedure(texture : GLuint; target : GLenum; origtexture : GLuint; internalformat : GLenum; minlevel : GLuint; numlevels : GLuint; minlayer : GLuint; numlayers : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_attrib_binding + TglBindVertexBuffer = procedure(bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribBinding = procedure(attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexBindingDivisor = procedure(bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayBindVertexBufferEXT = procedure(vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribIFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribLFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribBindingEXT = procedure(vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexBindingDivisorEXT = procedure(vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +var + // GL_VERSION_1_2 + glBlendColor: TglBlendColor; + glBlendEquation: TglBlendEquation; + glDrawRangeElements: TglDrawRangeElements; + glTexImage3D: TglTexImage3D; + glTexSubImage3D: TglTexSubImage3D; + glCopyTexSubImage3D: TglCopyTexSubImage3D; + glColorTable: TglColorTable; + glColorTableParameterfv: TglColorTableParameterfv; + glColorTableParameteriv: TglColorTableParameteriv; + glCopyColorTable: TglCopyColorTable; + glGetColorTable: TglGetColorTable; + glGetColorTableParameterfv: TglGetColorTableParameterfv; + glGetColorTableParameteriv: TglGetColorTableParameteriv; + glColorSubTable: TglColorSubTable; + glCopyColorSubTable: TglCopyColorSubTable; + glConvolutionFilter1D: TglConvolutionFilter1D; + glConvolutionFilter2D: TglConvolutionFilter2D; + glConvolutionParameterf: TglConvolutionParameterf; + glConvolutionParameterfv: TglConvolutionParameterfv; + glConvolutionParameteri: TglConvolutionParameteri; + glConvolutionParameteriv: TglConvolutionParameteriv; + glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D; + glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D; + glGetConvolutionFilter: TglGetConvolutionFilter; + glGetConvolutionParameterfv: TglGetConvolutionParameterfv; + glGetConvolutionParameteriv: TglGetConvolutionParameteriv; + glGetSeparableFilter: TglGetSeparableFilter; + glSeparableFilter2D: TglSeparableFilter2D; + glGetHistogram: TglGetHistogram; + glGetHistogramParameterfv: TglGetHistogramParameterfv; + glGetHistogramParameteriv: TglGetHistogramParameteriv; + glGetMinmax: TglGetMinmax; + glGetMinmaxParameterfv: TglGetMinmaxParameterfv; + glGetMinmaxParameteriv: TglGetMinmaxParameteriv; + glHistogram: TglHistogram; + glMinmax: TglMinmax; + glResetHistogram: TglResetHistogram; + glResetMinmax: TglResetMinmax; + // GL_VERSION_1_3 + glActiveTexture: TglActiveTexture; + glSampleCoverage: TglSampleCoverage; + glCompressedTexImage3D: TglCompressedTexImage3D; + glCompressedTexImage2D: TglCompressedTexImage2D; + glCompressedTexImage1D: TglCompressedTexImage1D; + glCompressedTexSubImage3D: TglCompressedTexSubImage3D; + glCompressedTexSubImage2D: TglCompressedTexSubImage2D; + glCompressedTexSubImage1D: TglCompressedTexSubImage1D; + glGetCompressedTexImage: TglGetCompressedTexImage; + glClientActiveTexture: TglClientActiveTexture; + glMultiTexCoord1d: TglMultiTexCoord1d; + glMultiTexCoord1dv: TglMultiTexCoord1dv; + glMultiTexCoord1f: TglMultiTexCoord1f; + glMultiTexCoord1fv: TglMultiTexCoord1fv; + glMultiTexCoord1i: TglMultiTexCoord1i; + glMultiTexCoord1iv: TglMultiTexCoord1iv; + glMultiTexCoord1s: TglMultiTexCoord1s; + glMultiTexCoord1sv: TglMultiTexCoord1sv; + glMultiTexCoord2d: TglMultiTexCoord2d; + glMultiTexCoord2dv: TglMultiTexCoord2dv; + glMultiTexCoord2f: TglMultiTexCoord2f; + glMultiTexCoord2fv: TglMultiTexCoord2fv; + glMultiTexCoord2i: TglMultiTexCoord2i; + glMultiTexCoord2iv: TglMultiTexCoord2iv; + glMultiTexCoord2s: TglMultiTexCoord2s; + glMultiTexCoord2sv: TglMultiTexCoord2sv; + glMultiTexCoord3d: TglMultiTexCoord3d; + glMultiTexCoord3dv: TglMultiTexCoord3dv; + glMultiTexCoord3f: TglMultiTexCoord3f; + glMultiTexCoord3fv: TglMultiTexCoord3fv; + glMultiTexCoord3i: TglMultiTexCoord3i; + glMultiTexCoord3iv: TglMultiTexCoord3iv; + glMultiTexCoord3s: TglMultiTexCoord3s; + glMultiTexCoord3sv: TglMultiTexCoord3sv; + glMultiTexCoord4d: TglMultiTexCoord4d; + glMultiTexCoord4dv: TglMultiTexCoord4dv; + glMultiTexCoord4f: TglMultiTexCoord4f; + glMultiTexCoord4fv: TglMultiTexCoord4fv; + glMultiTexCoord4i: TglMultiTexCoord4i; + glMultiTexCoord4iv: TglMultiTexCoord4iv; + glMultiTexCoord4s: TglMultiTexCoord4s; + glMultiTexCoord4sv: TglMultiTexCoord4sv; + glLoadTransposeMatrixf: TglLoadTransposeMatrixf; + glLoadTransposeMatrixd: TglLoadTransposeMatrixd; + glMultTransposeMatrixf: TglMultTransposeMatrixf; + glMultTransposeMatrixd: TglMultTransposeMatrixd; + // GL_VERSION_1_4 + glBlendFuncSeparate: TglBlendFuncSeparate; + glMultiDrawArrays: TglMultiDrawArrays; + glMultiDrawElements: TglMultiDrawElements; + glPointParameterf: TglPointParameterf; + glPointParameterfv: TglPointParameterfv; + glPointParameteri: TglPointParameteri; + glPointParameteriv: TglPointParameteriv; + glFogCoordf: TglFogCoordf; + glFogCoordfv: TglFogCoordfv; + glFogCoordd: TglFogCoordd; + glFogCoorddv: TglFogCoorddv; + glFogCoordPointer: TglFogCoordPointer; + glSecondaryColor3b: TglSecondaryColor3b; + glSecondaryColor3bv: TglSecondaryColor3bv; + glSecondaryColor3d: TglSecondaryColor3d; + glSecondaryColor3dv: TglSecondaryColor3dv; + glSecondaryColor3f: TglSecondaryColor3f; + glSecondaryColor3fv: TglSecondaryColor3fv; + glSecondaryColor3i: TglSecondaryColor3i; + glSecondaryColor3iv: TglSecondaryColor3iv; + glSecondaryColor3s: TglSecondaryColor3s; + glSecondaryColor3sv: TglSecondaryColor3sv; + glSecondaryColor3ub: TglSecondaryColor3ub; + glSecondaryColor3ubv: TglSecondaryColor3ubv; + glSecondaryColor3ui: TglSecondaryColor3ui; + glSecondaryColor3uiv: TglSecondaryColor3uiv; + glSecondaryColor3us: TglSecondaryColor3us; + glSecondaryColor3usv: TglSecondaryColor3usv; + glSecondaryColorPointer: TglSecondaryColorPointer; + glWindowPos2d: TglWindowPos2d; + glWindowPos2dv: TglWindowPos2dv; + glWindowPos2f: TglWindowPos2f; + glWindowPos2fv: TglWindowPos2fv; + glWindowPos2i: TglWindowPos2i; + glWindowPos2iv: TglWindowPos2iv; + glWindowPos2s: TglWindowPos2s; + glWindowPos2sv: TglWindowPos2sv; + glWindowPos3d: TglWindowPos3d; + glWindowPos3dv: TglWindowPos3dv; + glWindowPos3f: TglWindowPos3f; + glWindowPos3fv: TglWindowPos3fv; + glWindowPos3i: TglWindowPos3i; + glWindowPos3iv: TglWindowPos3iv; + glWindowPos3s: TglWindowPos3s; + glWindowPos3sv: TglWindowPos3sv; + // GL_VERSION_1_5 + glGenQueries: TglGenQueries; + glDeleteQueries: TglDeleteQueries; + glIsQuery: TglIsQuery; + glBeginQuery: TglBeginQuery; + glEndQuery: TglEndQuery; + glGetQueryiv: TglGetQueryiv; + glGetQueryObjectiv: TglGetQueryObjectiv; + glGetQueryObjectuiv: TglGetQueryObjectuiv; + glBindBuffer: TglBindBuffer; + glDeleteBuffers: TglDeleteBuffers; + glGenBuffers: TglGenBuffers; + glIsBuffer: TglIsBuffer; + glBufferData: TglBufferData; + glBufferSubData: TglBufferSubData; + glGetBufferSubData: TglGetBufferSubData; + glMapBuffer: TglMapBuffer; + glUnmapBuffer: TglUnmapBuffer; + glGetBufferParameteriv: TglGetBufferParameteriv; + glGetBufferPointerv: TglGetBufferPointerv; + // GL_VERSION_2_0 + glBlendEquationSeparate: TglBlendEquationSeparate; + glDrawBuffers: TglDrawBuffers; + glStencilOpSeparate: TglStencilOpSeparate; + glStencilFuncSeparate: TglStencilFuncSeparate; + glStencilMaskSeparate: TglStencilMaskSeparate; + glAttachShader: TglAttachShader; + glBindAttribLocation: TglBindAttribLocation; + glCompileShader: TglCompileShader; + glCreateProgram: TglCreateProgram; + glCreateShader: TglCreateShader; + glDeleteProgram: TglDeleteProgram; + glDeleteShader: TglDeleteShader; + glDetachShader: TglDetachShader; + glDisableVertexAttribArray: TglDisableVertexAttribArray; + glEnableVertexAttribArray: TglEnableVertexAttribArray; + glGetActiveAttrib: TglGetActiveAttrib; + glGetActiveUniform: TglGetActiveUniform; + glGetAttachedShaders: TglGetAttachedShaders; + glGetAttribLocation: TglGetAttribLocation; + glGetProgramiv: TglGetProgramiv; + glGetProgramInfoLog: TglGetProgramInfoLog; + glGetShaderiv: TglGetShaderiv; + glGetShaderInfoLog: TglGetShaderInfoLog; + glGetShaderSource: TglGetShaderSource; + glGetUniformLocation: TglGetUniformLocation; + glGetUniformfv: TglGetUniformfv; + glGetUniformiv: TglGetUniformiv; + glGetVertexAttribfv: TglGetVertexAttribfv; + glGetVertexAttribiv: TglGetVertexAttribiv; + glGetVertexAttribPointerv: TglGetVertexAttribPointerv; + glIsProgram: TglIsProgram; + glIsShader: TglIsShader; + glLinkProgram: TglLinkProgram; + glShaderSource: TglShaderSource; + glUseProgram: TglUseProgram; + glUniform1f: TglUniform1f; + glUniform2f: TglUniform2f; + glUniform3f: TglUniform3f; + glUniform4f: TglUniform4f; + glUniform1i: TglUniform1i; + glUniform2i: TglUniform2i; + glUniform3i: TglUniform3i; + glUniform4i: TglUniform4i; + glUniform1fv: TglUniform1fv; + glUniform2fv: TglUniform2fv; + glUniform3fv: TglUniform3fv; + glUniform4fv: TglUniform4fv; + glUniform1iv: TglUniform1iv; + glUniform2iv: TglUniform2iv; + glUniform3iv: TglUniform3iv; + glUniform4iv: TglUniform4iv; + glUniformMatrix2fv: TglUniformMatrix2fv; + glUniformMatrix3fv: TglUniformMatrix3fv; + glUniformMatrix4fv: TglUniformMatrix4fv; + glValidateProgram: TglValidateProgram; + glVertexAttrib1d: TglVertexAttrib1d; + glVertexAttrib1dv: TglVertexAttrib1dv; + glVertexAttrib1f: TglVertexAttrib1f; + glVertexAttrib1fv: TglVertexAttrib1fv; + glVertexAttrib1s: TglVertexAttrib1s; + glVertexAttrib1sv: TglVertexAttrib1sv; + glVertexAttrib2d: TglVertexAttrib2d; + glVertexAttrib2dv: TglVertexAttrib2dv; + glVertexAttrib2f: TglVertexAttrib2f; + glVertexAttrib2fv: TglVertexAttrib2fv; + glVertexAttrib2s: TglVertexAttrib2s; + glVertexAttrib2sv: TglVertexAttrib2sv; + glVertexAttrib3d: TglVertexAttrib3d; + glVertexAttrib3dv: TglVertexAttrib3dv; + glVertexAttrib3f: TglVertexAttrib3f; + glVertexAttrib3fv: TglVertexAttrib3fv; + glVertexAttrib3s: TglVertexAttrib3s; + glVertexAttrib3sv: TglVertexAttrib3sv; + glVertexAttrib4Nbv: TglVertexAttrib4Nbv; + glVertexAttrib4Niv: TglVertexAttrib4Niv; + glVertexAttrib4Nsv: TglVertexAttrib4Nsv; + glVertexAttrib4Nub: TglVertexAttrib4Nub; + glVertexAttrib4Nubv: TglVertexAttrib4Nubv; + glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv; + glVertexAttrib4Nusv: TglVertexAttrib4Nusv; + glVertexAttrib4bv: TglVertexAttrib4bv; + glVertexAttrib4d: TglVertexAttrib4d; + glVertexAttrib4dv: TglVertexAttrib4dv; + glVertexAttrib4f: TglVertexAttrib4f; + glVertexAttrib4fv: TglVertexAttrib4fv; + glVertexAttrib4iv: TglVertexAttrib4iv; + glVertexAttrib4s: TglVertexAttrib4s; + glVertexAttrib4sv: TglVertexAttrib4sv; + glVertexAttrib4ubv: TglVertexAttrib4ubv; + glVertexAttrib4uiv: TglVertexAttrib4uiv; + glVertexAttrib4usv: TglVertexAttrib4usv; + glVertexAttribPointer: TglVertexAttribPointer; + + // GL_VERSION_2_1 + glUniformMatrix2x3fv: TglUniformMatrix2x3fv; + glUniformMatrix3x2fv: TglUniformMatrix3x2fv; + glUniformMatrix2x4fv: TglUniformMatrix2x4fv; + glUniformMatrix4x2fv: TglUniformMatrix4x2fv; + glUniformMatrix3x4fv: TglUniformMatrix3x4fv; + glUniformMatrix4x3fv: TglUniformMatrix4x3fv; + + // GL_VERSION_3_0 + glColorMaski: TglColorMaski; + glGetBooleani_v: TglGetBooleani_v; + glGetIntegeri_v: TglGetIntegeri_v; + glEnablei: TglEnablei; + glDisablei: TglDisablei; + glIsEnabledi: TglIsEnabledi; + glBeginTransformFeedback: TglBeginTransformFeedback; + glEndTransformFeedback: TglEndTransformFeedback; + glBindBufferRange: TglBindBufferRange; + glBindBufferBase: TglBindBufferBase; + glTransformFeedbackVaryings: TglTransformFeedbackVaryings; + glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying; + glClampColor: TglClampColor; + glBeginConditionalRender: TglBeginConditionalRender; + glEndConditionalRender: TglEndConditionalRender; + glVertexAttribI1i: TglVertexAttribI1i; + glVertexAttribI2i: TglVertexAttribI2i; + glVertexAttribI3i: TglVertexAttribI3i; + glVertexAttribI4i: TglVertexAttribI4i; + glVertexAttribI1ui: TglVertexAttribI1ui; + glVertexAttribI2ui: TglVertexAttribI2ui; + glVertexAttribI3ui: TglVertexAttribI3ui; + glVertexAttribI4ui: TglVertexAttribI4ui; + glVertexAttribI1iv: TglVertexAttribI1iv; + glVertexAttribI2iv: TglVertexAttribI2iv; + glVertexAttribI3iv: TglVertexAttribI3iv; + glVertexAttribI4iv: TglVertexAttribI4iv; + glVertexAttribI1uiv: TglVertexAttribI1uiv; + glVertexAttribI2uiv: TglVertexAttribI2uiv; + glVertexAttribI3uiv: TglVertexAttribI3uiv; + glVertexAttribI4uiv: TglVertexAttribI4uiv; + glVertexAttribI4bv: TglVertexAttribI4bv; + glVertexAttribI4sv: TglVertexAttribI4sv; + glVertexAttribI4ubv: TglVertexAttribI4ubv; + glVertexAttribI4usv: TglVertexAttribI4usv; + glVertexAttribIPointer: TglVertexAttribIPointer; + glGetVertexAttribIiv: TglGetVertexAttribIiv; + glGetVertexAttribIuiv: TglGetVertexAttribIuiv; + glGetUniformuiv: TglGetUniformuiv; + glBindFragDataLocation: TglBindFragDataLocation; + glGetFragDataLocation: TglGetFragDataLocation; + glUniform1ui: TglUniform1ui; + glUniform2ui: TglUniform2ui; + glUniform3ui: TglUniform3ui; + glUniform4ui: TglUniform4ui; + glUniform1uiv: TglUniform1uiv; + glUniform2uiv: TglUniform2uiv; + glUniform3uiv: TglUniform3uiv; + glUniform4uiv: TglUniform4uiv; + glTexParameterIiv: TglTexParameterIiv; + glTexParameterIuiv: TglTexParameterIuiv; + glGetTexParameterIiv: TglGetTexParameterIiv; + glGetTexParameterIuiv: TglGetTexParameterIuiv; + glClearBufferiv: TglClearBufferiv; + glClearBufferuiv: TglClearBufferuiv; + glClearBufferfv: TglClearBufferfv; + glClearBufferfi: TglClearBufferfi; + glGetStringi: TglGetStringi; + + // GL_VERSION_2_1 + glEnableVertexArrayEXT : TglEnableVertexArrayEXT; + glEnableVertexArrayAttribEXT : TglEnableVertexArrayAttribEXT; + glVertexArrayVertexAttribOffsetEXT : TglVertexArrayVertexAttribOffsetEXT; + + // GL_VERSION_3_1 + glDrawArraysInstanced: TglDrawArraysInstanced; + glDrawElementsInstanced: TglDrawElementsInstanced; + glTexBuffer: TglTexBuffer; + glPrimitiveRestartIndex: TglPrimitiveRestartIndex; + + // GL_VERSION_3_2 + glGetInteger64i_v: TglGetInteger64i_v; + glGetBufferParameteri64v: TglGetBufferParameteri64v; + glFramebufferTexture: TglFramebufferTexture; + + // GL_VERSION_3_3 + glVertexAttribDivisor: TglVertexAttribDivisor; + + // GL_VERSION_4_0 + { OpenGL 4.0 also reuses entry points from these extensions: } + { ARB_texture_query_lod (no entry points) } + { ARB_draw_indirect } + { ARB_gpu_shader5 (no entry points) } + { ARB_gpu_shader_fp64 } + { ARB_shader_subroutine } + { ARB_tessellation_shader } + { ARB_texture_buffer_object_rgb32 (no entry points) } + { ARB_texture_cube_map_array (no entry points) } + { ARB_texture_gather (no entry points) } + { ARB_transform_feedback2 } + { ARB_transform_feedback3 } + glMinSampleShading: TglMinSampleShading; + glBlendEquationi: TglBlendEquationi; + glBlendEquationSeparatei: TglBlendEquationSeparatei; + glBlendFunci: TglBlendFunci; + glBlendFuncSeparatei: TglBlendFuncSeparatei; + + // GL_ARB_framebuffer_object + glIsRenderbuffer: TglIsRenderbuffer; + glBindRenderbuffer: TglBindRenderbuffer; + glDeleteRenderbuffers: TglDeleteRenderbuffers; + glGenRenderbuffers: TglGenRenderbuffers; + glRenderbufferStorage: TglRenderbufferStorage; + glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv; + glIsFramebuffer: TglIsFramebuffer; + glBindFramebuffer: TglBindFramebuffer; + glDeleteFramebuffers: TglDeleteFramebuffers; + glGenFramebuffers: TglGenFramebuffers; + glCheckFramebufferStatus: TglCheckFramebufferStatus; + glFramebufferTexture1D: TglFramebufferTexture1D; + glFramebufferTexture2D: TglFramebufferTexture2D; + glFramebufferTexture3D: TglFramebufferTexture3D; + glFramebufferRenderbuffer: TglFramebufferRenderbuffer; + glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv; + glGenerateMipmap: TglGenerateMipmap; + glBlitFramebuffer: TglBlitFramebuffer; + glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample; + glFramebufferTextureLayer: TglFramebufferTextureLayer; + + // GL_ARB_map_buffer_range + glMapBufferRange: TglMapBufferRange; + glFlushMappedBufferRange: TglFlushMappedBufferRange; + + // GL_ARB_vertex_array_object + glBindVertexArray: TglBindVertexArray; + glDeleteVertexArrays: TglDeleteVertexArrays; + glGenVertexArrays: TglGenVertexArrays; + glIsVertexArray: TglIsVertexArray; + + // GL_ARB_uniform_buffer_object + glGetUniformIndices: TglGetUniformIndices; + glGetActiveUniformsiv: TglGetActiveUniformsiv; + glGetActiveUniformName: TglGetActiveUniformName; + glGetUniformBlockIndex: TglGetUniformBlockIndex; + glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv; + glGetActiveUniformBlockName: TglGetActiveUniformBlockName; + glUniformBlockBinding: TglUniformBlockBinding; + + // GL_ARB_copy_buffer + glCopyBufferSubData: TglCopyBufferSubData; + + // GL_ARB_draw_elements_base_vertex + glDrawElementsBaseVertex: TglDrawElementsBaseVertex; + glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex; + glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex; + glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex; + + // GL_ARB_provoking_vertex + glProvokingVertex: TglProvokingVertex; + + // GL_ARB_sync + glFenceSync: TglFenceSync; + glIsSync: TglIsSync; + glDeleteSync: TglDeleteSync; + glClientWaitSync: TglClientWaitSync; + glWaitSync: TglWaitSync; + glGetInteger64v: TglGetInteger64v; + glGetSynciv: TglGetSynciv; + + // GL_ARB_texture_multisample + glTexImage2DMultisample: TglTexImage2DMultisample; + glTexImage3DMultisample: TglTexImage3DMultisample; + glGetMultisamplefv: TglGetMultisamplefv; + glSampleMaski: TglSampleMaski; + + // GL_ARB_blend_func_extended + glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed; + glGetFragDataIndex: TglGetFragDataIndex; + + // GL_ARB_sampler_objects + glGenSamplers: TglGenSamplers; + glDeleteSamplers: TglDeleteSamplers; + glIsSampler: TglIsSampler; + glBindSampler: TglBindSampler; + glSamplerParameteri: TglSamplerParameteri; + glSamplerParameteriv: TglSamplerParameteriv; + glSamplerParameterf: TglSamplerParameterf; + glSamplerParameterfv: TglSamplerParameterfv; + glSamplerParameterIiv: TglSamplerParameterIiv; + glSamplerParameterIuiv: TglSamplerParameterIuiv; + glGetSamplerParameteriv: TglGetSamplerParameteriv; + glGetSamplerParameterIiv: TglGetSamplerParameterIiv; + glGetSamplerParameterfv: TglGetSamplerParameterfv; + glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv; + + // GL_ARB_timer_query + glQueryCounter: TglQueryCounter; + glGetQueryObjecti64v: TglGetQueryObjecti64v; + glGetQueryObjectui64v: TglGetQueryObjectui64v; + + // GL_ARB_vertex_type_2_10_10_10_rev + glVertexP2ui: TglVertexP2ui; + glVertexP2uiv: TglVertexP2uiv; + glVertexP3ui: TglVertexP3ui; + glVertexP3uiv: TglVertexP3uiv; + glVertexP4ui: TglVertexP4ui; + glVertexP4uiv: TglVertexP4uiv; + glTexCoordP1ui: TglTexCoordP1ui; + glTexCoordP1uiv: TglTexCoordP1uiv; + glTexCoordP2ui: TglTexCoordP2ui; + glTexCoordP2uiv: TglTexCoordP2uiv; + glTexCoordP3ui: TglTexCoordP3ui; + glTexCoordP3uiv: TglTexCoordP3uiv; + glTexCoordP4ui: TglTexCoordP4ui; + glTexCoordP4uiv: TglTexCoordP4uiv; + glMultiTexCoordP1ui: TglMultiTexCoordP1ui; + glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv; + glMultiTexCoordP2ui: TglMultiTexCoordP2ui; + glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv; + glMultiTexCoordP3ui: TglMultiTexCoordP3ui; + glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv; + glMultiTexCoordP4ui: TglMultiTexCoordP4ui; + glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv; + glNormalP3ui: TglNormalP3ui; + glNormalP3uiv: TglNormalP3uiv; + glColorP3ui: TglColorP3ui; + glColorP3uiv: TglColorP3uiv; + glColorP4ui: TglColorP4ui; + glColorP4uiv: TglColorP4uiv; + glSecondaryColorP3ui: TglSecondaryColorP3ui; + glSecondaryColorP3uiv: TglSecondaryColorP3uiv; + glVertexAttribP1ui: TglVertexAttribP1ui; + glVertexAttribP1uiv: TglVertexAttribP1uiv; + glVertexAttribP2ui: TglVertexAttribP2ui; + glVertexAttribP2uiv: TglVertexAttribP2uiv; + glVertexAttribP3ui: TglVertexAttribP3ui; + glVertexAttribP3uiv: TglVertexAttribP3uiv; + glVertexAttribP4ui: TglVertexAttribP4ui; + glVertexAttribP4uiv: TglVertexAttribP4uiv; + + // GL_ARB_draw_indirect + glDrawArraysIndirect: TglDrawArraysIndirect; + glDrawElementsIndirect: TglDrawElementsIndirect; + + // GL_ARB_gpu_shader_fp64 + glUniform1d: TglUniform1d; + glUniform2d: TglUniform2d; + glUniform3d: TglUniform3d; + glUniform4d: TglUniform4d; + glUniform1dv: TglUniform1dv; + glUniform2dv: TglUniform2dv; + glUniform3dv: TglUniform3dv; + glUniform4dv: TglUniform4dv; + glUniformMatrix2dv: TglUniformMatrix2dv; + glUniformMatrix3dv: TglUniformMatrix3dv; + glUniformMatrix4dv: TglUniformMatrix4dv; + glUniformMatrix2x3dv: TglUniformMatrix2x3dv; + glUniformMatrix2x4dv: TglUniformMatrix2x4dv; + glUniformMatrix3x2dv: TglUniformMatrix3x2dv; + glUniformMatrix3x4dv: TglUniformMatrix3x4dv; + glUniformMatrix4x2dv: TglUniformMatrix4x2dv; + glUniformMatrix4x3dv: TglUniformMatrix4x3dv; + glGetUniformdv: TglGetUniformdv; + + // GL_ARB_shader_subroutine + glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation; + glGetSubroutineIndex: TglGetSubroutineIndex; + glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv; + glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName; + glGetActiveSubroutineName: TglGetActiveSubroutineName; + glUniformSubroutinesuiv: TglUniformSubroutinesuiv; + glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv; + glGetProgramStageiv: TglGetProgramStageiv; + + // GL_ARB_tessellation_shader + glPatchParameteri: TglPatchParameteri; + glPatchParameterfv: TglPatchParameterfv; + + // GL_ARB_transform_feedback2 + glBindTransformFeedback: TglBindTransformFeedback; + glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks; + glGenTransformFeedbacks: TglGenTransformFeedbacks; + glIsTransformFeedback: TglIsTransformFeedback; + glPauseTransformFeedback: TglPauseTransformFeedback; + glResumeTransformFeedback: TglResumeTransformFeedback; + glDrawTransformFeedback: TglDrawTransformFeedback; + + // GL_ARB_transform_feedback3 + glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream; + glBeginQueryIndexed: TglBeginQueryIndexed; + glEndQueryIndexed: TglEndQueryIndexed; + glGetQueryIndexediv: TglGetQueryIndexediv; + + // GL_ARB_ES2_compatibility + glReleaseShaderCompiler: TglReleaseShaderCompiler; + glShaderBinary: TglShaderBinary; + glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat; + glDepthRangef: TglDepthRangef; + glClearDepthf: TglClearDepthf; + + // GL_ARB_get_program_binary + glGetProgramBinary: TglGetProgramBinary; + glProgramBinary: TglProgramBinary; + glProgramParameteri: TglProgramParameteri; + + // GL_ARB_separate_shader_objects + glUseProgramStages: TglUseProgramStages; + glActiveShaderProgram: TglActiveShaderProgram; + glCreateShaderProgramv: TglCreateShaderProgramv; + glBindProgramPipeline: TglBindProgramPipeline; + glDeleteProgramPipelines: TglDeleteProgramPipelines; + glGenProgramPipelines: TglGenProgramPipelines; + glIsProgramPipeline: TglIsProgramPipeline; + glGetProgramPipelineiv: TglGetProgramPipelineiv; + glProgramUniform1i: TglProgramUniform1i; + glProgramUniform1iv: TglProgramUniform1iv; + glProgramUniform1f: TglProgramUniform1f; + glProgramUniform1fv: TglProgramUniform1fv; + glProgramUniform1d: TglProgramUniform1d; + glProgramUniform1dv: TglProgramUniform1dv; + glProgramUniform1ui: TglProgramUniform1ui; + glProgramUniform1uiv: TglProgramUniform1uiv; + glProgramUniform2i: TglProgramUniform2i; + glProgramUniform2iv: TglProgramUniform2iv; + glProgramUniform2f: TglProgramUniform2f; + glProgramUniform2fv: TglProgramUniform2fv; + glProgramUniform2d: TglProgramUniform2d; + glProgramUniform2dv: TglProgramUniform2dv; + glProgramUniform2ui: TglProgramUniform2ui; + glProgramUniform2uiv: TglProgramUniform2uiv; + glProgramUniform3i: TglProgramUniform3i; + glProgramUniform3iv: TglProgramUniform3iv; + glProgramUniform3f: TglProgramUniform3f; + glProgramUniform3fv: TglProgramUniform3fv; + glProgramUniform3d: TglProgramUniform3d; + glProgramUniform3dv: TglProgramUniform3dv; + glProgramUniform3ui: TglProgramUniform3ui; + glProgramUniform3uiv: TglProgramUniform3uiv; + glProgramUniform4i: TglProgramUniform4i; + glProgramUniform4iv: TglProgramUniform4iv; + glProgramUniform4f: TglProgramUniform4f; + glProgramUniform4fv: TglProgramUniform4fv; + glProgramUniform4d: TglProgramUniform4d; + glProgramUniform4dv: TglProgramUniform4dv; + glProgramUniform4ui: TglProgramUniform4ui; + glProgramUniform4uiv: TglProgramUniform4uiv; + glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv; + glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv; + glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv; + glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv; + glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv; + glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv; + glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv; + glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv; + glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv; + glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv; + glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv; + glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv; + glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv; + glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv; + glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv; + glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv; + glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv; + glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv; + glValidateProgramPipeline: TglValidateProgramPipeline; + glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog; + + // GL_ARB_vertex_attrib_64bit + glVertexAttribL1d: TglVertexAttribL1d; + glVertexAttribL2d: TglVertexAttribL2d; + glVertexAttribL3d: TglVertexAttribL3d; + glVertexAttribL4d: TglVertexAttribL4d; + glVertexAttribL1dv: TglVertexAttribL1dv; + glVertexAttribL2dv: TglVertexAttribL2dv; + glVertexAttribL3dv: TglVertexAttribL3dv; + glVertexAttribL4dv: TglVertexAttribL4dv; + glVertexAttribLPointer: TglVertexAttribLPointer; + glGetVertexAttribLdv: TglGetVertexAttribLdv; + + // GL_ARB_viewport_array + glViewportArrayv: TglViewportArrayv; + glViewportIndexedf: TglViewportIndexedf; + glViewportIndexedfv: TglViewportIndexedfv; + glScissorArrayv: TglScissorArrayv; + glScissorIndexed: TglScissorIndexed; + glScissorIndexedv: TglScissorIndexedv; + glDepthRangeArrayv: TglDepthRangeArrayv; + glDepthRangeIndexed: TglDepthRangeIndexed; + glGetFloati_v: TglGetFloati_v; + glGetDoublei_v: TglGetDoublei_v; + + // GL 4.2 + + // GL_ARB_base_instance + glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance; + glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance; + glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance; + + // GL_ARB_transform_feedback_instanced + glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced; + glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced; + + // GL_ARB_internalformat_query + glGetInternalformativ : TglGetInternalformativ; + + // GL_ARB_shader_atomic_counters + glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv; + + /// GL_ARB_shader_image_load_store + glBindImageTexture : TglBindImageTexture; + glMemoryBarrier : TglMemoryBarrier; + + // GL_ARB_texture_storage + glTexStorage1D : TglTexStorage1D; + glTexStorage2D : TglTexStorage2D; + glTexStorage3D : TglTexStorage3D; + + // GL 4.3 + // GL_ARB_clear_buffer_object + glClearBufferData : TglClearBufferData; + glClearBufferSubData : TglClearBufferSubData; + // GL_ARB_compute_shader + glDispatchCompute : TglDispatchCompute; + glDispatchComputeIndirect : TglDispatchComputeIndirect; + // GL_ARB_copy_image + glCopyImageSubData : TglCopyImageSubData; + // GL_ARB_framebuffer_no_attachments + glFramebufferParameteri : TglFramebufferParameteri; + glGetFramebufferParameteriv : TglGetFramebufferParameteriv; + // GL_ARB_internalformat_query2 + glGetInternalformati64v : TglGetInternalformati64v; + // GL_ARB_invalidate_subdata + glInvalidateTexSubImage : TglInvalidateTexSubImage; + glInvalidateTexImage : TglInvalidateTexImage; + glInvalidateBufferSubData : TglInvalidateBufferSubData; + glInvalidateBufferData : TglInvalidateBufferData; + glInvalidateFramebuffer : TglInvalidateFramebuffer; + glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer; + // GL_ARB_multi_draw_indirect + glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect; + glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect; + // GL_ARB_program_interface_query + glGetProgramInterfaceiv : TglGetProgramInterfaceiv; + glGetProgramResourceIndex : TglGetProgramResourceIndex; + glGetProgramResourceName : TglGetProgramResourceName; + glGetProgramResourceiv : TglGetProgramResourceiv; + glGetProgramResourceLocation : TglGetProgramResourceLocation; + glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex; + // GL_ARB_shader_storage_buffer_object + glShaderStorageBlockBinding : TglShaderStorageBlockBinding; + // GL_ARB_texture_buffer_range + glTexBufferRange : TglTexBufferRange; + // GL_ARB_texture_storage_multisample + glTexStorage2DMultisample : TglTexStorage2DMultisample; + glTexStorage3DMultisample : TglTexStorage3DMultisample; + // GL_ARB_texture_view + glTextureView : TglTextureView; + // GL_ARB_vertex_attrib_binding + glBindVertexBuffer : TglBindVertexBuffer; + glVertexAttribFormat : TglVertexAttribFormat; + glVertexAttribIFormat : TglVertexAttribIFormat; + glVertexAttribLFormat : TglVertexAttribLFormat; + glVertexAttribBinding : TglVertexAttribBinding; + glVertexBindingDivisor : TglVertexBindingDivisor; + // END GL 4.3 + + // GL 4.4 + glBufferStorage : TglBufferStorage; + glClearTexImage : TglClearTexImage; + glClearTexSubImage : TglClearTexSubImage; + glBindBuffersBase : TglBindBuffersBase; + glBindBuffersRange : TglBindBuffersRange; + glBindTextures : TglBindTextures; + glBindSamplers : TglBindSamplers; + glBindImageTextures : TglBindImageTextures; + glBindVertexBuffers : TglBindVertexBuffers; + + // GL 4.5 + glClipControl : TglClipControl; + glCreateTransformFeedbacks : TglCreateTransformFeedbacks; + glTransformFeedbackBufferBase : TglTransformFeedbackBufferBase; + glTransformFeedbackBufferRange : TglTransformFeedbackBufferRange; + glGetTransformFeedbackiv : TglGetTransformFeedbackiv; + glGetTransformFeedbacki_v : TglGetTransformFeedbacki_v; + glGetTransformFeedbacki64_v : TglGetTransformFeedbacki64_v; + glCreateBuffers : TglCreateBuffers; + glNamedBufferStorage : TglNamedBufferStorage; + glNamedBufferData : TglNamedBufferData; + glNamedBufferSubData : TglNamedBufferSubData; + glCopyNamedBufferSubData : TglCopyNamedBufferSubData; + glClearNamedBufferData : TglClearNamedBufferData; + glClearNamedBufferSubData : TglClearNamedBufferSubData; + glMapNamedBuffer : TglMapNamedBuffer; + glMapNamedBufferRange : TglMapNamedBufferRange; + glUnmapNamedBuffer : TglUnmapNamedBuffer; + glFlushMappedNamedBufferRange : TglFlushMappedNamedBufferRange; + glGetNamedBufferParameteriv : TglGetNamedBufferParameteriv; + glGetNamedBufferParameteri64v : TglGetNamedBufferParameteri64v; + glGetNamedBufferPointerv : TglGetNamedBufferPointerv; + glGetNamedBufferSubData : TglGetNamedBufferSubData; + glCreateFramebuffers : TglCreateFramebuffers; + glNamedFramebufferRenderbuffer : TglNamedFramebufferRenderbuffer; + glNamedFramebufferParameteri : TglNamedFramebufferParameteri; + glNamedFramebufferTexture : TglNamedFramebufferTexture; + glNamedFramebufferTextureLayer : TglNamedFramebufferTextureLayer; + glNamedFramebufferDrawBuffer : TglNamedFramebufferDrawBuffer; + glNamedFramebufferDrawBuffers : TglNamedFramebufferDrawBuffers; + glNamedFramebufferReadBuffer : TglNamedFramebufferReadBuffer; + glInvalidateNamedFramebufferData : TglInvalidateNamedFramebufferData; + glInvalidateNamedFramebufferSubData : TglInvalidateNamedFramebufferSubData; + glClearNamedFramebufferiv : TglClearNamedFramebufferiv; + glClearNamedFramebufferuiv : TglClearNamedFramebufferuiv; + glClearNamedFramebufferfv : TglClearNamedFramebufferfv; + glClearNamedFramebufferfi : TglClearNamedFramebufferfi; + glBlitNamedFramebuffer : TglBlitNamedFramebuffer; + glCheckNamedFramebufferStatus : TglCheckNamedFramebufferStatus; + glGetNamedFramebufferParameteriv : TglGetNamedFramebufferParameteriv; + glGetNamedFramebufferAttachmentParameteriv : TglGetNamedFramebufferAttachmentParameteriv; + glCreateRenderbuffers : TglCreateRenderbuffers; + glNamedRenderbufferStorage : TglNamedRenderbufferStorage; + glNamedRenderbufferStorageMultisample : TglNamedRenderbufferStorageMultisample; + glGetNamedRenderbufferParameteriv : TglGetNamedRenderbufferParameteriv; + glCreateTextures : TglCreateTextures; + glTextureBuffer : TglTextureBuffer; + glTextureBufferRange : TglTextureBufferRange; + glTextureStorage1D : TglTextureStorage1D; + glTextureStorage2D : TglTextureStorage2D; + glTextureStorage3D : TglTextureStorage3D; + glTextureStorage2DMultisample : TglTextureStorage2DMultisample; + glTextureStorage3DMultisample : TglTextureStorage3DMultisample; + glTextureSubImage1D : TglTextureSubImage1D; + glTextureSubImage2D : TglTextureSubImage2D; + glTextureSubImage3D : TglTextureSubImage3D; + glCompressedTextureSubImage1D : TglCompressedTextureSubImage1D; + glCompressedTextureSubImage2D : TglCompressedTextureSubImage2D; + glCompressedTextureSubImage3D : TglCompressedTextureSubImage3D; + glCopyTextureSubImage1D : TglCopyTextureSubImage1D; + glCopyTextureSubImage2D : TglCopyTextureSubImage2D; + glCopyTextureSubImage3D : TglCopyTextureSubImage3D; + glTextureParameterf : TglTextureParameterf; + glTextureParameterfv : TglTextureParameterfv; + glTextureParameteri : TglTextureParameteri; + glTextureParameterIiv : TglTextureParameterIiv; + glTextureParameterIuiv : TglTextureParameterIuiv; + glTextureParameteriv : TglTextureParameteriv; + glGenerateTextureMipmap : TglGenerateTextureMipmap; + glBindTextureUnit : TglBindTextureUnit; + glGetTextureImage : TglGetTextureImage; + glGetCompressedTextureImage : TglGetCompressedTextureImage; + glGetTextureLevelParameterfv : TglGetTextureLevelParameterfv; + glGetTextureLevelParameteriv : TglGetTextureLevelParameteriv; + glGetTextureParameterfv : TglGetTextureParameterfv; + glGetTextureParameterIiv : TglGetTextureParameterIiv; + glGetTextureParameterIuiv : TglGetTextureParameterIuiv; + glGetTextureParameteriv : TglGetTextureParameteriv; + glCreateVertexArrays : TglCreateVertexArrays; + glDisableVertexArrayAttrib : TglDisableVertexArrayAttrib; + glEnableVertexArrayAttrib : TglEnableVertexArrayAttrib; + glVertexArrayElementBuffer : TglVertexArrayElementBuffer; + glVertexArrayVertexBuffer : TglVertexArrayVertexBuffer; + glVertexArrayVertexBuffers : TglVertexArrayVertexBuffers; + glVertexArrayAttribBinding : TglVertexArrayAttribBinding; + glVertexArrayAttribFormat : TglVertexArrayAttribFormat; + glVertexArrayAttribIFormat : TglVertexArrayAttribIFormat; + glVertexArrayAttribLFormat : TglVertexArrayAttribLFormat; + glVertexArrayBindingDivisor : TglVertexArrayBindingDivisor; + glGetVertexArrayiv : TglGetVertexArrayiv; + glGetVertexArrayIndexediv : TglGetVertexArrayIndexediv; + glGetVertexArrayIndexed64iv : TglGetVertexArrayIndexed64iv; + glCreateSamplers : TglCreateSamplers; + glCreateProgramPipelines : TglCreateProgramPipelines; + glCreateQueries : TglCreateQueries; + glMemoryBarrierByRegion : TglMemoryBarrierByRegion; + glGetTextureSubImage : TglGetTextureSubImage; + glGetCompressedTextureSubImage : TglGetCompressedTextureSubImage; + glGetGraphicsResetStatus : TglGetGraphicsResetStatus; + glGetnCompressedTexImage : TglGetnCompressedTexImage; + glGetnTexImage : TglGetnTexImage; + glGetnUniformdv : TglGetnUniformdv; + glGetnUniformfv : TglGetnUniformfv; + glGetnUniformiv : TglGetnUniformiv; + glGetnUniformuiv : TglGetnUniformuiv; + glReadnPixels : TglReadnPixels; + glGetnMapdv : TglGetnMapdv; + glGetnMapfv : TglGetnMapfv; + glGetnMapiv : TglGetnMapiv; + glGetnPixelMapfv : TglGetnPixelMapfv; + glGetnPixelMapuiv : TglGetnPixelMapuiv; + glGetnPixelMapusv : TglGetnPixelMapusv; + glGetnPolygonStipple : TglGetnPolygonStipple; + glGetnColorTable : TglGetnColorTable; + glGetnConvolutionFilter : TglGetnConvolutionFilter; + glGetnSeparableFilter : TglGetnSeparableFilter; + glGetnHistogram : TglGetnHistogram; + glGetnMinmax : TglGetnMinmax; + glTextureBarrier : TglTextureBarrier; + +type + TRCOptions = set of (opDoubleBuffered, opGDI, opStereo); + +var + GL_LibHandle: Pointer = nil; + LastPixelFormat: Integer; + ExtensionsRead: Boolean; + ImplementationRead: Boolean; + +implementation + +end. diff --git a/README.md b/README.md new file mode 100644 index 0000000..5603e2c --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +This tool allows you to use flexible camera, shown on picture below over WiFi. Writed in Delphi 7. +

System Requirements

+ +
Operating systemWindows 7 or newer +
VideoOpenGL 4.5 compatible

+