code stringlengths 1 1.72M | language stringclasses 1
value |
|---|---|
#!/usr/bin/python
# $Id:$
import ctypes
import pyglet
from pyglet.input import base
from pyglet.libs import win32
from pyglet.libs.win32 import dinput
from pyglet.libs.win32 import _kernel32
# These instance names are not defined anywhere, obtained by experiment. The
# GUID names (which seem to be ideally what are needed) are wrong/missing for
# most of my devices.
_abs_instance_names = {
0: 'x',
1: 'y',
2: 'z',
3: 'rx',
4: 'ry',
5: 'rz',
}
_rel_instance_names = {
0: 'x',
1: 'y',
2: 'wheel',
}
_btn_instance_names = {}
def _create_control(object_instance):
raw_name = object_instance.tszName
type = object_instance.dwType
instance = dinput.DIDFT_GETINSTANCE(type)
if type & dinput.DIDFT_ABSAXIS:
name = _abs_instance_names.get(instance)
control = base.AbsoluteAxis(name, 0, 0xffff, raw_name)
elif type & dinput.DIDFT_RELAXIS:
name = _rel_instance_names.get(instance)
control = base.RelativeAxis(name, raw_name)
elif type & dinput.DIDFT_BUTTON:
name = _btn_instance_names.get(instance)
control = base.Button(name, raw_name)
elif type & dinput.DIDFT_POV:
control = base.AbsoluteAxis(base.AbsoluteAxis.HAT,
0, 0xffffffff, raw_name)
else:
return
control._type = object_instance.dwType
return control
class DirectInputDevice(base.Device):
def __init__(self, display, device, device_instance):
name = device_instance.tszInstanceName
super(DirectInputDevice, self).__init__(display, name)
self._type = device_instance.dwDevType & 0xff
self._subtype = device_instance.dwDevType & 0xff00
self._device = device
self._init_controls()
self._set_format()
def _init_controls(self):
self.controls = []
self._device.EnumObjects(
dinput.LPDIENUMDEVICEOBJECTSCALLBACK(self._object_enum),
None, dinput.DIDFT_ALL)
def _object_enum(self, object_instance, arg):
control = _create_control(object_instance.contents)
if control:
self.controls.append(control)
return dinput.DIENUM_CONTINUE
def _set_format(self):
if not self.controls:
return
object_formats = (dinput.DIOBJECTDATAFORMAT * len(self.controls))()
offset = 0
for object_format, control in zip(object_formats, self.controls):
object_format.dwOfs = offset
object_format.dwType = control._type
offset += 4
format = dinput.DIDATAFORMAT()
format.dwSize = ctypes.sizeof(format)
format.dwObjSize = ctypes.sizeof(dinput.DIOBJECTDATAFORMAT)
format.dwFlags = 0
format.dwDataSize = offset
format.dwNumObjs = len(object_formats)
format.rgodf = ctypes.cast(ctypes.pointer(object_formats),
dinput.LPDIOBJECTDATAFORMAT)
self._device.SetDataFormat(format)
prop = dinput.DIPROPDWORD()
prop.diph.dwSize = ctypes.sizeof(prop)
prop.diph.dwHeaderSize = ctypes.sizeof(prop.diph)
prop.diph.dwObj = 0
prop.diph.dwHow = dinput.DIPH_DEVICE
prop.dwData = 64 * ctypes.sizeof(dinput.DIDATAFORMAT)
self._device.SetProperty(dinput.DIPROP_BUFFERSIZE,
ctypes.byref(prop.diph))
def open(self, window=None, exclusive=False):
if not self.controls:
return
if window is None:
# Pick any open window, or the shadow window if no windows
# have been created yet.
window = pyglet.gl._shadow_window
for window in pyglet.app.windows:
break
flags = dinput.DISCL_BACKGROUND
if exclusive:
flags |= dinput.DISCL_EXCLUSIVE
else:
flags |= dinput.DISCL_NONEXCLUSIVE
self._wait_object = _kernel32.CreateEventW(None, False, False, None)
self._device.SetEventNotification(self._wait_object)
pyglet.app.platform_event_loop.add_wait_object(self._wait_object,
self._dispatch_events)
self._device.SetCooperativeLevel(window._hwnd, flags)
self._device.Acquire()
def close(self):
if not self.controls:
return
pyglet.app.platform_event_loop.remove_wait_object(self._wait_object)
self._device.Unacquire()
self._device.SetEventNotification(None)
_kernel32.CloseHandle(self._wait_object)
def get_controls(self):
return self.controls
def _dispatch_events(self):
if not self.controls:
return
events = (dinput.DIDEVICEOBJECTDATA * 64)()
n_events = win32.DWORD(len(events))
self._device.GetDeviceData(ctypes.sizeof(dinput.DIDEVICEOBJECTDATA),
ctypes.cast(ctypes.pointer(events),
dinput.LPDIDEVICEOBJECTDATA),
ctypes.byref(n_events),
0)
for event in events[:n_events.value]:
index = event.dwOfs // 4
self.controls[index]._set_value(event.dwData)
_i_dinput = None
def _init_directinput():
global _i_dinput
if _i_dinput:
return
_i_dinput = dinput.IDirectInput8()
module = _kernel32.GetModuleHandleW(None)
dinput.DirectInput8Create(module, dinput.DIRECTINPUT_VERSION,
dinput.IID_IDirectInput8W,
ctypes.byref(_i_dinput), None)
def get_devices(display=None):
_init_directinput()
_devices = []
def _device_enum(device_instance, arg):
device = dinput.IDirectInputDevice8()
_i_dinput.CreateDevice(device_instance.contents.guidInstance,
ctypes.byref(device),
None)
_devices.append(DirectInputDevice(display,
device, device_instance.contents))
return dinput.DIENUM_CONTINUE
_i_dinput.EnumDevices(dinput.DI8DEVCLASS_ALL,
dinput.LPDIENUMDEVICESCALLBACK(_device_enum),
None, dinput.DIEDFL_ATTACHEDONLY)
return _devices
def _create_joystick(device):
if device._type in (dinput.DI8DEVTYPE_JOYSTICK,
dinput.DI8DEVTYPE_GAMEPAD):
return base.Joystick(device)
def get_joysticks(display=None):
return filter(None, [_create_joystick(d) for d in get_devices(display)])
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import ctypes
import pyglet
from pyglet.libs.darwin import carbon, _oscheck, create_cfstring
from pyglet.libs.darwin.constants import *
from base import Device, Control, AbsoluteAxis, RelativeAxis, Button
from base import Joystick, AppleRemote
from base import DeviceExclusiveException
# non-broken c_void_p
void_p = ctypes.POINTER(ctypes.c_int)
class CFUUIDBytes(ctypes.Structure):
_fields_ = [('byte%d' % i, ctypes.c_uint8) for i in range(16)]
mach_port_t = void_p
io_iterator_t = void_p
kern_return_t = ctypes.c_int
IOReturn = ctypes.c_uint
CFDictionaryRef = void_p
CFMutableDictionaryRef = void_p
CFArrayRef = void_p
CFStringRef = void_p
CFUUIDRef = ctypes.POINTER(CFUUIDBytes)
AbsoluteTime = ctypes.c_double
HRESULT = ctypes.c_int
REFIID = CFUUIDBytes
IOHIDElementType = ctypes.c_int
kIOHIDElementTypeInput_Misc = 1
kIOHIDElementTypeInput_Button = 2
kIOHIDElementTypeInput_Axis = 3
kIOHIDElementTypeInput_ScanCodes = 4
kIOHIDElementTypeOutput = 129
kIOHIDElementTypeFeature = 257
kIOHIDElementTypeCollection = 513
IOHIDElementCookie = ctypes.c_void_p
# Full list in IOHIDUsageTables.h
kHIDPage_GenericDesktop = 0x01
kHIDUsage_GD_Joystick = 0x04
kHIDUsage_GD_GamePad = 0x05
kHIDUsage_GD_Keyboard = 0x06
kHIDUsage_GD_Keypad = 0x07
kHIDUsage_GD_MultiAxisController = 0x08
kHIDUsage_GD_SystemAppMenu = 0x86
kHIDUsage_GD_SystemMenu = 0x89
kHIDUsage_GD_SystemMenuRight = 0x8A
kHIDUsage_GD_SystemMenuLeft = 0x8B
kHIDUsage_GD_SystemMenuUp = 0x8C
kHIDUsage_GD_SystemMenuDown = 0x8D
kHIDPage_Consumer = 0x0C
kHIDUsage_Csmr_Menu = 0x40
kHIDUsage_Csmr_FastForward = 0xB3
kHIDUsage_Csmr_Rewind = 0xB4
MACH_PORT_NULL = 0
kIOHIDDeviceKey = "IOHIDDevice"
kIOServicePlane = "IOService"
kIOHIDProductIDKey = "ProductID"
kCFNumberIntType = 9
kIOHIDOptionsTypeSeizeDevice = 1
kIOReturnExclusiveAccess = 0xe00002c5
carbon.CFUUIDGetConstantUUIDWithBytes.restype = CFUUIDRef
kIOHIDDeviceUserClientTypeID = carbon.CFUUIDGetConstantUUIDWithBytes(None,
0xFA, 0x12, 0xFA, 0x38, 0x6F, 0x1A, 0x11, 0xD4,
0xBA, 0x0C, 0x00, 0x05, 0x02, 0x8F, 0x18, 0xD5)
kIOCFPlugInInterfaceID = carbon.CFUUIDGetConstantUUIDWithBytes(None,
0xC2, 0x44, 0xE8, 0x58, 0x10, 0x9C, 0x11, 0xD4,
0x91, 0xD4, 0x00, 0x50, 0xE4, 0xC6, 0x42, 0x6F)
kIOHIDDeviceInterfaceID = carbon.CFUUIDGetConstantUUIDWithBytes(None,
0x78, 0xBD, 0x42, 0x0C, 0x6F, 0x14, 0x11, 0xD4,
0x94, 0x74, 0x00, 0x05, 0x02, 0x8F, 0x18, 0xD5)
IOHIDCallbackFunction = ctypes.CFUNCTYPE(None,
void_p, IOReturn, ctypes.c_void_p, ctypes.c_void_p)
CFRunLoopSourceRef = ctypes.c_void_p
class IOHIDEventStruct(ctypes.Structure):
_fields_ = (
('type', IOHIDElementType),
('elementCookie', IOHIDElementCookie),
('value', ctypes.c_int32),
('timestamp', AbsoluteTime),
('longValueSize', ctypes.c_uint32),
('longValue', ctypes.c_void_p)
)
Self = ctypes.c_void_p
class IUnknown(ctypes.Structure):
_fields_ = (
('_reserved', ctypes.c_void_p),
('QueryInterface',
ctypes.CFUNCTYPE(HRESULT, Self, REFIID, ctypes.c_void_p)),
('AddRef',
ctypes.CFUNCTYPE(ctypes.c_ulong, Self)),
('Release',
ctypes.CFUNCTYPE(ctypes.c_ulong, Self)),
)
# Most of these function prototypes are not filled in yet because I haven't
# bothered.
class IOHIDQueueInterface(ctypes.Structure):
_fields_ = IUnknown._fields_ + (
('createAsyncEventSource', ctypes.CFUNCTYPE(IOReturn,
Self, ctypes.POINTER(CFRunLoopSourceRef))),
('getAsyncEventSource', ctypes.c_void_p),
('createAsyncPort', ctypes.c_void_p),
('getAsyncPort', ctypes.c_void_p),
('create', ctypes.CFUNCTYPE(IOReturn,
Self, ctypes.c_uint32, ctypes.c_uint32)),
('dispose', ctypes.CFUNCTYPE(IOReturn,
Self)),
('addElement', ctypes.CFUNCTYPE(IOReturn,
Self, IOHIDElementCookie)),
('removeElement', ctypes.c_void_p),
('hasElement', ctypes.c_void_p),
('start', ctypes.CFUNCTYPE(IOReturn,
Self)),
('stop', ctypes.CFUNCTYPE(IOReturn,
Self)),
('getNextEvent', ctypes.CFUNCTYPE(IOReturn,
Self, ctypes.POINTER(IOHIDEventStruct), AbsoluteTime,
ctypes.c_uint32)),
('setEventCallout', ctypes.CFUNCTYPE(IOReturn,
Self, IOHIDCallbackFunction, ctypes.c_void_p, ctypes.c_void_p)),
('getEventCallout', ctypes.c_void_p),
)
class IOHIDDeviceInterface(ctypes.Structure):
_fields_ = IUnknown._fields_ + (
('createAsyncEventSource', ctypes.c_void_p),
('getAsyncEventSource', ctypes.c_void_p),
('createAsyncPort', ctypes.c_void_p),
('getAsyncPort', ctypes.c_void_p),
('open', ctypes.CFUNCTYPE(IOReturn,
Self, ctypes.c_uint32)),
('close', ctypes.CFUNCTYPE(IOReturn,
Self)),
('setRemovalCallback', ctypes.c_void_p),
('getElementValue', ctypes.CFUNCTYPE(IOReturn,
Self, IOHIDElementCookie, ctypes.POINTER(IOHIDEventStruct))),
('setElementValue', ctypes.c_void_p),
('queryElementValue', ctypes.c_void_p),
('startAllQueues', ctypes.c_void_p),
('stopAllQueues', ctypes.c_void_p),
('allocQueue', ctypes.CFUNCTYPE(
ctypes.POINTER(ctypes.POINTER(IOHIDQueueInterface)),
Self)),
('allocOutputTransaction', ctypes.c_void_p),
# 1.2.1 (10.2.3)
('setReport', ctypes.c_void_p),
('getReport', ctypes.c_void_p),
# 1.2.2 (10.3)
('copyMatchingElements', ctypes.CFUNCTYPE(IOReturn,
Self, CFDictionaryRef, ctypes.POINTER(CFArrayRef))),
('setInterruptReportHandlerCallback', ctypes.c_void_p),
)
def get_master_port():
master_port = mach_port_t()
_oscheck(
carbon.IOMasterPort(MACH_PORT_NULL, ctypes.byref(master_port))
)
return master_port
def get_matching_dictionary():
carbon.IOServiceMatching.restype = CFMutableDictionaryRef
matching_dictionary = carbon.IOServiceMatching(kIOHIDDeviceKey)
return matching_dictionary
def get_matching_services(master_port, matching_dictionary):
# Consumes reference to matching_dictionary
iterator = io_iterator_t()
_oscheck(
carbon.IOServiceGetMatchingServices(master_port,
matching_dictionary,
ctypes.byref(iterator))
)
services = []
while carbon.IOIteratorIsValid(iterator):
service = carbon.IOIteratorNext(iterator)
if not service:
break
services.append(service)
carbon.IOObjectRelease(iterator)
return services
def cfstring_to_string(value_string):
value_length = carbon.CFStringGetLength(value_string)
buffer_length = carbon.CFStringGetMaximumSizeForEncoding(
value_length, kCFStringEncodingUTF8)
buffer = ctypes.c_buffer(buffer_length + 1)
result = carbon.CFStringGetCString(value_string,
buffer,
len(buffer),
kCFStringEncodingUTF8)
if not result:
return
return buffer.value
def cfnumber_to_int(value):
result = ctypes.c_int()
carbon.CFNumberGetValue(value, kCFNumberIntType, ctypes.byref(result))
return result.value
def cfboolean_to_bool(value):
return bool(carbon.CFBooleanGetValue(value))
def cfvalue_to_value(value):
if not value:
return None
value_type = carbon.CFGetTypeID(value)
if value_type == carbon.CFStringGetTypeID():
return cfstring_to_string(value)
elif value_type == carbon.CFNumberGetTypeID():
return cfnumber_to_int(value)
elif value_type == carbon.CFBooleanGetTypeID():
return cfboolean_to_bool(value)
else:
return None
def get_property_value(properties, key):
key_string = create_cfstring(key)
value = ctypes.c_void_p()
present = carbon.CFDictionaryGetValueIfPresent(properties,
key_string,
ctypes.byref(value))
carbon.CFRelease(key_string)
if not present:
return None
return value
def get_property(properties, key):
return cfvalue_to_value(get_property_value(properties, key))
def dump_properties(properties):
def func(key, value, context):
print '%s = %s' % (cfstring_to_string(key), cfvalue_to_value(value))
CFDictionaryApplierFunction = ctypes.CFUNCTYPE(None,
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p)
carbon.CFDictionaryApplyFunction(properties,
CFDictionaryApplierFunction(func), None)
class DarwinHIDDevice(Device):
'''
:IVariables:
`name` : str
`manufacturer` : str
'''
def __init__(self, display, generic_device):
super(DarwinHIDDevice, self).__init__(display, name=None)
self._device = self._get_device_interface(generic_device)
properties = CFMutableDictionaryRef()
_oscheck(
carbon.IORegistryEntryCreateCFProperties(generic_device,
ctypes.byref(properties),
None, 0)
)
self.name = get_property(properties, "Product")
self.manufacturer = get_property(properties, "Manufacturer")
self.usage_page = get_property(properties, 'PrimaryUsagePage')
self.usage = get_property(properties, 'PrimaryUsage')
carbon.CFRelease(properties)
self._controls = self._init_controls()
self._open = False
self._queue = None
self._queue_depth = 8 # Number of events queue can buffer
def _get_device_interface(self, generic_device):
plug_in_interface = \
ctypes.POINTER(ctypes.POINTER(IUnknown))()
score = ctypes.c_int32()
_oscheck(
carbon.IOCreatePlugInInterfaceForService(
generic_device,
kIOHIDDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
ctypes.byref(plug_in_interface),
ctypes.byref(score))
)
carbon.CFUUIDGetUUIDBytes.restype = CFUUIDBytes
hid_device_interface = \
ctypes.POINTER(ctypes.POINTER(IOHIDDeviceInterface))()
_oscheck(
plug_in_interface.contents.contents.QueryInterface(
plug_in_interface,
carbon.CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
ctypes.byref(hid_device_interface))
)
plug_in_interface.contents.contents.Release(plug_in_interface)
return hid_device_interface
def _init_controls(self):
elements_array = CFArrayRef()
_oscheck(
self._device.contents.contents.copyMatchingElements(self._device,
None, ctypes.byref(elements_array))
)
self._control_cookies = {}
controls = []
n_elements = carbon.CFArrayGetCount(elements_array)
for i in range(n_elements):
properties = carbon.CFArrayGetValueAtIndex(elements_array, i)
control = _create_control(properties)
if control:
controls.append(control)
self._control_cookies[control._cookie] = control
carbon.CFRelease(elements_array)
return controls
def open(self, window=None, exclusive=False):
super(DarwinHIDDevice, self).open(window, exclusive)
flags = 0
if exclusive:
flags |= kIOHIDOptionsTypeSeizeDevice
result = self._device.contents.contents.open(self._device, flags)
if result == 0:
self._open = True
elif result == kIOReturnExclusiveAccess:
raise DeviceExclusiveException()
# Create event queue
self._queue = self._device.contents.contents.allocQueue(self._device)
_oscheck(
self._queue.contents.contents.create(self._queue,
0, self._queue_depth)
)
# Add all controls into queue
for control in self._controls:
r = self._queue.contents.contents.addElement(self._queue,
control._cookie, 0)
if r != 0:
print 'error adding %r' % control
self._event_source = CFRunLoopSourceRef()
self._queue_callback_func = IOHIDCallbackFunction(self._queue_callback)
_oscheck(
self._queue.contents.contents.createAsyncEventSource(self._queue,
ctypes.byref(self._event_source))
)
_oscheck(
self._queue.contents.contents.setEventCallout(self._queue,
self._queue_callback_func, None, None)
)
event_loop = pyglet.app.platform_event_loop._event_loop
carbon.GetCFRunLoopFromEventLoop.restype = void_p
run_loop = carbon.GetCFRunLoopFromEventLoop(event_loop)
kCFRunLoopDefaultMode = \
CFStringRef.in_dll(carbon, 'kCFRunLoopDefaultMode')
carbon.CFRunLoopAddSource(run_loop,
self._event_source,
kCFRunLoopDefaultMode)
_oscheck(
self._queue.contents.contents.start(self._queue)
)
def close(self):
super(DarwinHIDDevice, self).close()
if not self._open:
return
_oscheck(
self._queue.contents.contents.stop(self._queue)
)
_oscheck(
self._queue.contents.contents.dispose(self._queue)
)
self._queue.contents.contents.Release(self._queue)
self._queue = None
_oscheck(
self._device.contents.contents.close(self._device)
)
self._open = False
def get_controls(self):
return self._controls
def _queue_callback(self, target, result, refcon, sender):
if not self._open:
return
event = IOHIDEventStruct()
r = self._queue.contents.contents.getNextEvent(self._queue,
ctypes.byref(event), 0, 0)
while r == 0:
try:
control = self._control_cookies[event.elementCookie]
control._set_value(event.value)
except KeyError:
pass
r = self._queue.contents.contents.getNextEvent(self._queue,
ctypes.byref(event), 0, 0)
_axis_names = {
(0x01, 0x30): 'x',
(0x01, 0x31): 'y',
(0x01, 0x32): 'z',
(0x01, 0x33): 'rx',
(0x01, 0x34): 'ry',
(0x01, 0x35): 'rz',
(0x01, 0x38): 'wheel',
(0x01, 0x39): 'hat',
}
_button_names = {
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemAppMenu): 'menu',
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemMenu): 'select',
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemMenuRight): 'right',
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemMenuLeft): 'left',
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemMenuUp): 'up',
(kHIDPage_GenericDesktop, kHIDUsage_GD_SystemMenuDown): 'down',
(kHIDPage_Consumer, kHIDUsage_Csmr_FastForward): 'right_hold',
(kHIDPage_Consumer, kHIDUsage_Csmr_Rewind): 'left_hold',
(kHIDPage_Consumer, kHIDUsage_Csmr_Menu): 'menu_hold',
(0xff01, 0x23): 'select_hold',
}
def _create_control(properties):
type = get_property(properties, 'Type')
if type not in (kIOHIDElementTypeInput_Misc,
kIOHIDElementTypeInput_Axis,
kIOHIDElementTypeInput_Button):
return
cookie = get_property(properties, 'ElementCookie')
usage_page = get_property(properties, 'UsagePage')
usage = get_property(properties, 'Usage')
raw_name = get_property(properties, 'Name')
if not raw_name:
raw_name = '%d:%d' % (usage_page, usage)
if type in (kIOHIDElementTypeInput_Misc, kIOHIDElementTypeInput_Axis):
name = _axis_names.get((usage_page, usage))
relative = get_property(properties, 'IsRelative')
if relative:
control = RelativeAxis(name, raw_name)
else:
min = get_property(properties, 'Min')
max = get_property(properties, 'Max')
control = AbsoluteAxis(name, min, max, raw_name)
elif type == kIOHIDElementTypeInput_Button:
name = _button_names.get((usage_page, usage))
control = Button(name, raw_name)
else:
return
control._cookie = cookie
return control
def _create_joystick(device):
# Ignore desktop devices that are not joysticks, gamepads or m-a controllers
if device.usage_page == kHIDPage_GenericDesktop and \
device.usage not in (kHIDUsage_GD_Joystick,
kHIDUsage_GD_GamePad,
kHIDUsage_GD_MultiAxisController):
return
# Anything else is interesting enough to be a joystick?
return Joystick(device)
def get_devices(display=None):
services = get_matching_services(get_master_port(),
get_matching_dictionary())
return [DarwinHIDDevice(display, service) for service in services]
def get_joysticks(display=None):
return filter(None,
[_create_joystick(device) for device in get_devices(display)])
def get_apple_remote(display=None):
for device in get_devices(display):
if device.name == 'Apple IR':
return AppleRemote(device)
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import pyglet
from pyglet.input.base import \
Tablet, TabletCanvas, TabletCursor, DeviceOpenException
from pyglet.input.x11_xinput import \
get_devices, XInputWindowEventDispatcher, DeviceResponder
try:
from pyglet.libs.x11 import xinput as xi
_have_xinput = True
except:
_have_xinput = False
class XInputTablet(Tablet):
name = 'XInput Tablet'
def __init__(self, cursors):
self.cursors = cursors
def open(self, window):
return XInputTabletCanvas(window, self.cursors)
class XInputTabletCanvas(DeviceResponder, TabletCanvas):
def __init__(self, window, cursors):
super(XInputTabletCanvas, self).__init__(window)
self.cursors = cursors
dispatcher = XInputWindowEventDispatcher.get_dispatcher(window)
self.display = window.display
self._open_devices = []
self._cursor_map = {}
for cursor in cursors:
device = cursor.device
device_id = device._device_id
self._cursor_map[device_id] = cursor
cursor.max_pressure = device.axes[2].max
if self.display._display != device.display._display:
raise DeviceOpenException('Window and device displays differ')
open_device = xi.XOpenDevice(device.display._display, device_id)
if not open_device:
# Ignore this cursor; fail if no cursors added
continue
self._open_devices.append(open_device)
dispatcher.open_device(device_id, open_device, self)
def close(self):
for device in self._open_devices:
xi.XCloseDevice(self.display._display, device)
def _motion(self, e):
cursor = self._cursor_map.get(e.deviceid)
x = e.x
y = self.window.height - e.y
pressure = e.axis_data[2] / float(cursor.max_pressure)
self.dispatch_event('on_motion', cursor, x, y, pressure, 0.0, 0.0)
def _proximity_in(self, e):
cursor = self._cursor_map.get(e.deviceid)
self.dispatch_event('on_enter', cursor)
def _proximity_out(self, e):
cursor = self._cursor_map.get(e.deviceid)
self.dispatch_event('on_leave', cursor)
class XInputTabletCursor(TabletCursor):
def __init__(self, device):
super(XInputTabletCursor, self).__init__(device.name)
self.device = device
def get_tablets(display=None):
# Each cursor appears as a separate xinput device; find devices that look
# like Wacom tablet cursors and amalgamate them into a single tablet.
cursors = []
devices = get_devices(display)
for device in devices:
if device.name in ('stylus', 'cursor', 'eraser') and \
len(device.axes) >= 3:
cursors.append(XInputTabletCursor(device))
if cursors:
return [XInputTablet(cursors)]
return []
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
import errno
import os
import pyglet
from pyglet.app.xlib import XlibSelectDevice
from base import Device, Control, RelativeAxis, AbsoluteAxis, Button, Joystick
from base import DeviceOpenException
from evdev_constants import *
from evdev_constants import _rel_raw_names, _abs_raw_names, _key_raw_names
c = pyglet.lib.load_library('c')
_IOC_NRBITS = 8
_IOC_TYPEBITS = 8
_IOC_SIZEBITS = 14
_IOC_DIRBITS = 2
_IOC_NRMASK = ((1 << _IOC_NRBITS)-1)
_IOC_TYPEMASK = ((1 << _IOC_TYPEBITS)-1)
_IOC_SIZEMASK = ((1 << _IOC_SIZEBITS)-1)
_IOC_DIRMASK = ((1 << _IOC_DIRBITS)-1)
_IOC_NRSHIFT = 0
_IOC_TYPESHIFT = (_IOC_NRSHIFT+_IOC_NRBITS)
_IOC_SIZESHIFT = (_IOC_TYPESHIFT+_IOC_TYPEBITS)
_IOC_DIRSHIFT = (_IOC_SIZESHIFT+_IOC_SIZEBITS)
_IOC_NONE = 0
_IOC_WRITE = 1
_IOC_READ = 2
def _IOC(dir, type, nr, size):
return ((dir << _IOC_DIRSHIFT) |
(type << _IOC_TYPESHIFT) |
(nr << _IOC_NRSHIFT) |
(size << _IOC_SIZESHIFT))
def _IOR(type, nr, struct):
request = _IOC(_IOC_READ, ord(type), nr, ctypes.sizeof(struct))
def f(fileno):
buffer = struct()
if c.ioctl(fileno, request, ctypes.byref(buffer)) < 0:
err = ctypes.c_int.in_dll(c, 'errno').value
raise OSError(err, errno.errorcode[err])
return buffer
return f
def _IOR_len(type, nr):
def f(fileno, buffer):
request = _IOC(_IOC_READ, ord(type), nr, ctypes.sizeof(buffer))
if c.ioctl(fileno, request, ctypes.byref(buffer)) < 0:
err = ctypes.c_int.in_dll(c, 'errno').value
raise OSError(err, errno.errorcode[err])
return buffer
return f
def _IOR_str(type, nr):
g = _IOR_len(type, nr)
def f(fileno, len=256):
return g(fileno, ctypes.create_string_buffer(len)).value
return f
time_t = ctypes.c_long
suseconds_t = ctypes.c_long
class timeval(ctypes.Structure):
_fields_ = (
('tv_sec', time_t),
('tv_usec', suseconds_t)
)
class input_event(ctypes.Structure):
_fields_ = (
('time', timeval),
('type', ctypes.c_uint16),
('code', ctypes.c_uint16),
('value', ctypes.c_int32)
)
class input_id(ctypes.Structure):
_fields_ = (
('bustype', ctypes.c_uint16),
('vendor', ctypes.c_uint16),
('product', ctypes.c_uint16),
('version', ctypes.c_uint16),
)
class input_absinfo(ctypes.Structure):
_fields_ = (
('value', ctypes.c_int32),
('minimum', ctypes.c_int32),
('maximum', ctypes.c_int32),
('fuzz', ctypes.c_int32),
('flat', ctypes.c_int32),
)
EVIOCGVERSION = _IOR('E', 0x01, ctypes.c_int)
EVIOCGID = _IOR('E', 0x02, input_id)
EVIOCGNAME = _IOR_str('E', 0x06)
EVIOCGPHYS = _IOR_str('E', 0x07)
EVIOCGUNIQ = _IOR_str('E', 0x08)
def EVIOCGBIT(fileno, ev, buffer):
return _IOR_len('E', 0x20 + ev)(fileno, buffer)
def EVIOCGABS(fileno, abs):
buffer = input_absinfo()
return _IOR_len('E', 0x40 + abs)(fileno, buffer)
def get_set_bits(bytes):
bits = set()
j = 0
for byte in bytes:
for i in range(8):
if byte & 1:
bits.add(j + i)
byte >>= 1
j += 8
return bits
_abs_names = {
ABS_X: AbsoluteAxis.X,
ABS_Y: AbsoluteAxis.Y,
ABS_Z: AbsoluteAxis.Z,
ABS_RX: AbsoluteAxis.RX,
ABS_RY: AbsoluteAxis.RY,
ABS_RZ: AbsoluteAxis.RZ,
ABS_HAT0X: AbsoluteAxis.HAT_X,
ABS_HAT0Y: AbsoluteAxis.HAT_Y,
}
_rel_names = {
REL_X: RelativeAxis.X,
REL_Y: RelativeAxis.Y,
REL_Z: RelativeAxis.Z,
REL_RX: RelativeAxis.RX,
REL_RY: RelativeAxis.RY,
REL_RZ: RelativeAxis.RZ,
REL_WHEEL: RelativeAxis.WHEEL,
}
def _create_control(fileno, event_type, event_code):
if event_type == EV_ABS:
raw_name = _abs_raw_names.get(event_code, 'EV_ABS(%x)' % event_code)
name = _abs_names.get(event_code)
absinfo = EVIOCGABS(fileno, event_code)
value = absinfo.value
min = absinfo.minimum
max = absinfo.maximum
control = AbsoluteAxis(name, min, max, raw_name)
control._set_value(value)
if name == 'hat_y':
control.inverted = True
elif event_type == EV_REL:
raw_name = _rel_raw_names.get(event_code, 'EV_REL(%x)' % event_code)
name = _rel_names.get(event_code)
# TODO min/max?
control = RelativeAxis(name, raw_name)
elif event_type == EV_KEY:
raw_name = _key_raw_names.get(event_code, 'EV_KEY(%x)' % event_code)
name = None
control = Button(name, raw_name)
else:
value = min = max = 0 # TODO
return None
control._event_type = event_type
control._event_code = event_code
return control
def _create_joystick(device):
# Look for something with an ABS X and ABS Y axis, and a joystick 0 button
have_x = False
have_y = False
have_button = False
for control in device.controls:
if control._event_type == EV_ABS and control._event_code == ABS_X:
have_x = True
elif control._event_type == EV_ABS and control._event_code == ABS_Y:
have_y = True
elif control._event_type == EV_KEY and \
control._event_code in (BTN_JOYSTICK, BTN_GAMEPAD):
have_button = True
if not (have_x and have_y and have_button):
return
return Joystick(device)
event_types = {
EV_KEY: KEY_MAX,
EV_REL: REL_MAX,
EV_ABS: ABS_MAX,
EV_MSC: MSC_MAX,
EV_LED: LED_MAX,
EV_SND: SND_MAX,
}
class EvdevDevice(XlibSelectDevice, Device):
_fileno = None
def __init__(self, display, filename):
self._filename = filename
fileno = os.open(filename, os.O_RDONLY)
#event_version = EVIOCGVERSION(fileno).value
id = EVIOCGID(fileno)
self.id_bustype = id.bustype
self.id_vendor = hex(id.vendor)
self.id_product = hex(id.product)
self.id_version = id.version
name = EVIOCGNAME(fileno)
try:
name = name.decode('utf-8')
except UnicodeDecodeError:
try:
name = name.decode('latin-1')
except UnicodeDecodeError:
pass
try:
self.phys = EVIOCGPHYS(fileno)
except OSError:
self.phys = ''
try:
self.uniq = EVIOCGUNIQ(fileno)
except OSError:
self.uniq = ''
self.controls = []
self.control_map = {}
event_types_bits = (ctypes.c_byte * 4)()
EVIOCGBIT(fileno, 0, event_types_bits)
for event_type in get_set_bits(event_types_bits):
if event_type not in event_types:
continue
max_code = event_types[event_type]
nbytes = max_code // 8 + 1
event_codes_bits = (ctypes.c_byte * nbytes)()
EVIOCGBIT(fileno, event_type, event_codes_bits)
for event_code in get_set_bits(event_codes_bits):
control = _create_control(fileno, event_type, event_code)
if control:
self.control_map[(event_type, event_code)] = control
self.controls.append(control)
os.close(fileno)
super(EvdevDevice, self).__init__(display, name)
def open(self, window=None, exclusive=False):
super(EvdevDevice, self).open(window, exclusive)
try:
self._fileno = os.open(self._filename, os.O_RDONLY | os.O_NONBLOCK)
except OSError, e:
raise DeviceOpenException(e)
pyglet.app.platform_event_loop._select_devices.add(self)
def close(self):
super(EvdevDevice, self).close()
if not self._fileno:
return
pyglet.app.platform_event_loop._select_devices.remove(self)
os.close(self._fileno)
self._fileno = None
def get_controls(self):
return self.controls
# XlibSelectDevice interface
def fileno(self):
return self._fileno
def poll(self):
# TODO
return False
def select(self):
if not self._fileno:
return
events = (input_event * 64)()
bytes = c.read(self._fileno, events, ctypes.sizeof(events))
if bytes < 0:
return
n_events = bytes // ctypes.sizeof(input_event)
for event in events[:n_events]:
try:
control = self.control_map[(event.type, event.code)]
control._set_value(event.value)
except KeyError:
pass
_devices = {}
def get_devices(display=None):
base = '/dev/input'
for filename in os.listdir(base):
if filename.startswith('event'):
path = os.path.join(base, filename)
if path in _devices:
continue
try:
_devices[path] = EvdevDevice(display, path)
except OSError:
pass
return _devices.values()
def get_joysticks(display=None):
return filter(None, [_create_joystick(d) for d in get_devices(display)])
| Python |
#!/usr/bin/python
# $Id:$
import ctypes
import pyglet
from pyglet.input.base import DeviceOpenException
from pyglet.input.base import Tablet, TabletCursor, TabletCanvas
from pyglet.libs.win32 import libwintab as wintab
lib = wintab.lib
def wtinfo(category, index, buffer):
size = lib.WTInfoW(category, index, None)
assert size <= ctypes.sizeof(buffer)
lib.WTInfoW(category, index, ctypes.byref(buffer))
return buffer
def wtinfo_string(category, index):
size = lib.WTInfoW(category, index, None)
buffer = ctypes.create_unicode_buffer(size)
lib.WTInfoW(category, index, buffer)
return buffer.value
def wtinfo_uint(category, index):
buffer = wintab.UINT()
lib.WTInfoW(category, index, ctypes.byref(buffer))
return buffer.value
def wtinfo_word(category, index):
buffer = wintab.WORD()
lib.WTInfoW(category, index, ctypes.byref(buffer))
return buffer.value
def wtinfo_dword(category, index):
buffer = wintab.DWORD()
lib.WTInfoW(category, index, ctypes.byref(buffer))
return buffer.value
def wtinfo_wtpkt(category, index):
buffer = wintab.WTPKT()
lib.WTInfoW(category, index, ctypes.byref(buffer))
return buffer.value
def wtinfo_bool(category, index):
buffer = wintab.BOOL()
lib.WTInfoW(category, index, ctypes.byref(buffer))
return bool(buffer.value)
class WintabTablet(Tablet):
def __init__(self, index):
self._device = wintab.WTI_DEVICES + index
self.name = wtinfo_string(self._device, wintab.DVC_NAME).strip()
self.id = wtinfo_string(self._device, wintab.DVC_PNPID)
hardware = wtinfo_uint(self._device, wintab.DVC_HARDWARE)
#phys_cursors = hardware & wintab.HWC_PHYSID_CURSORS
n_cursors = wtinfo_uint(self._device, wintab.DVC_NCSRTYPES)
first_cursor = wtinfo_uint(self._device, wintab.DVC_FIRSTCSR)
self.pressure_axis = wtinfo(self._device, wintab.DVC_NPRESSURE,
wintab.AXIS())
self.cursors = []
self._cursor_map = {}
for i in range(n_cursors):
cursor = WintabTabletCursor(self, i + first_cursor)
if not cursor.bogus:
self.cursors.append(cursor)
self._cursor_map[i + first_cursor] = cursor
def open(self, window):
return WintabTabletCanvas(self, window)
class WintabTabletCanvas(TabletCanvas):
def __init__(self, device, window, msg_base=wintab.WT_DEFBASE):
super(WintabTabletCanvas, self).__init__(window)
self.device = device
self.msg_base = msg_base
# Just use system context, for similarity w/ os x and xinput.
# WTI_DEFCONTEXT detaches mouse from tablet, which is nice, but not
# possible on os x afiak.
self.context_info = context_info = wintab.LOGCONTEXT()
wtinfo(wintab.WTI_DEFSYSCTX, 0, context_info)
context_info.lcMsgBase = msg_base
context_info.lcOptions |= wintab.CXO_MESSAGES
# If you change this, change definition of PACKET also.
context_info.lcPktData = (
wintab.PK_CHANGED | wintab.PK_CURSOR | wintab.PK_BUTTONS |
wintab.PK_X | wintab.PK_Y | wintab.PK_Z |
wintab.PK_NORMAL_PRESSURE | wintab.PK_TANGENT_PRESSURE |
wintab.PK_ORIENTATION)
context_info.lcPktMode = 0 # All absolute
self._context = lib.WTOpenW(window._hwnd,
ctypes.byref(context_info), True)
if not self._context:
raise DeviceOpenException("Couldn't open tablet context")
window._event_handlers[msg_base + wintab.WT_PACKET] = \
self._event_wt_packet
window._event_handlers[msg_base + wintab.WT_PROXIMITY] = \
self._event_wt_proximity
self._current_cursor = None
self._pressure_scale = device.pressure_axis.get_scale()
self._pressure_bias = device.pressure_axis.get_bias()
def close(self):
lib.WTClose(self._context)
self._context = None
del self.window._event_handlers[self.msg_base + wintab.WT_PACKET]
del self.window._event_handlers[self.msg_base + wintab.WT_PROXIMITY]
def _set_current_cursor(self, cursor_type):
if self._current_cursor:
self.dispatch_event('on_leave', self._current_cursor)
self._current_cursor = self.device._cursor_map.get(cursor_type, None)
if self._current_cursor:
self.dispatch_event('on_enter', self._current_cursor)
@pyglet.window.win32.Win32EventHandler(0)
def _event_wt_packet(self, msg, wParam, lParam):
if lParam != self._context:
return
packet = wintab.PACKET()
if lib.WTPacket(self._context, wParam, ctypes.byref(packet)) == 0:
return
if not packet.pkChanged:
return
window_x, window_y = self.window.get_location() # TODO cache on window
window_y = self.window.screen.height - window_y - self.window.height
x = packet.pkX - window_x
y = packet.pkY - window_y
pressure = (packet.pkNormalPressure + self._pressure_bias) * \
self._pressure_scale
if self._current_cursor is None:
self._set_current_cursor(packet.pkCursor)
self.dispatch_event('on_motion', self._current_cursor,
x, y, pressure, 0., 0.)
print packet.pkButtons
@pyglet.window.win32.Win32EventHandler(0)
def _event_wt_proximity(self, msg, wParam, lParam):
if wParam != self._context:
return
if not lParam & 0xffff0000:
# Not a hardware proximity event
return
if not lParam & 0xffff:
# Going out
self.dispatch_event('on_leave', self._current_cursor)
# If going in, proximity event will be generated by next event, which
# can actually grab a cursor id.
self._current_cursor = None
class WintabTabletCursor(object):
def __init__(self, device, index):
self.device = device
self._cursor = wintab.WTI_CURSORS + index
self.name = wtinfo_string(self._cursor, wintab.CSR_NAME).strip()
self.active = wtinfo_bool(self._cursor, wintab.CSR_ACTIVE)
pktdata = wtinfo_wtpkt(self._cursor, wintab.CSR_PKTDATA)
# A whole bunch of cursors are reported by the driver, but most of
# them are hogwash. Make sure a cursor has at least X and Y data
# before adding it to the device.
self.bogus = not (pktdata & wintab.PK_X and pktdata & wintab.PK_Y)
if self.bogus:
return
self.id = (wtinfo_dword(self._cursor, wintab.CSR_TYPE) << 32) | \
wtinfo_dword(self._cursor, wintab.CSR_PHYSID)
def __repr__(self):
return 'WintabCursor(%r)' % self.name
def get_spec_version():
spec_version = wtinfo_word(wintab.WTI_INTERFACE, wintab.IFC_SPECVERSION)
return spec_version
def get_interface_name():
interface_name = wtinfo_string(wintab.WTI_INTERFACE, wintab.IFC_WINTABID)
return interface_name
def get_implementation_version():
impl_version = wtinfo_word(wintab.WTI_INTERFACE, wintab.IFC_IMPLVERSION)
return impl_version
def get_tablets(display=None):
# Require spec version 1.1 or greater
if get_spec_version() < 0x101:
return []
n_devices = wtinfo_uint(wintab.WTI_INTERFACE, wintab.IFC_NDEVICES)
devices = [WintabTablet(i) for i in range(n_devices)]
return devices
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Joystick, tablet and USB HID device support.
This module provides a unified interface to almost any input device, besides
the regular mouse and keyboard support provided by `Window`. At the lowest
level, `get_devices` can be used to retrieve a list of all supported devices,
including joysticks, tablets, space controllers, wheels, pedals, remote
controls, keyboards and mice. The set of returned devices varies greatly
depending on the operating system (and, of course, what's plugged in).
At this level pyglet does not try to interpret *what* a particular device is,
merely what controls it provides. A `Control` can be either a button, whose
value is either ``True`` or ``False``, or a relative or absolute-valued axis,
whose value is a float. Sometimes the name of a control can be provided (for
example, ``x``, representing the horizontal axis of a joystick), but often
not. In these cases the device API may still be useful -- the user will have
to be asked to press each button in turn or move each axis separately to
identify them.
Higher-level interfaces are provided for joysticks, tablets and the Apple
remote control. These devices can usually be identified by pyglet positively,
and a base level of functionality for each one provided through a common
interface.
To use an input device:
1. Call `get_devices`, `get_apple_remote` or `get_joysticks`
to retrieve and identify the device.
2. For low-level devices (retrieved by `get_devices`), query the devices
list of controls and determine which ones you are interested in. For
high-level interfaces the set of controls is provided by the interface.
3. Optionally attach event handlers to controls on the device.
4. Call `Device.open` to begin receiving events on the device. You can
begin querying the control values after this time; they will be updated
asynchronously.
5. Call `Device.close` when you are finished with the device (not needed
if your application quits at this time).
To use a tablet, follow the procedure above using `get_tablets`, but note that
no control list is available; instead, calling `Tablet.open` returns a
`TabletCanvas` onto which you should set your event handlers.
:since: pyglet 1.2
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import sys
from base import Device, Control, RelativeAxis, AbsoluteAxis, \
Button, Joystick, AppleRemote, Tablet
from base import DeviceException, DeviceOpenException, DeviceExclusiveException
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
def get_apple_remote(display=None):
'''Get the Apple remote control device.
The Apple remote is the small white 6-button remote control that
accompanies most recent Apple desktops and laptops. The remote can only
be used with Mac OS X.
:Parameters:
`display` : `Display`
Currently ignored.
:rtype: `AppleRemote`
:return: The remote device, or ``None`` if the computer does not support
it.
'''
return None
if _is_epydoc:
def get_devices(display=None):
'''Get a list of all attached input devices.
:Parameters:
`display` : `Display`
The display device to query for input devices. Ignored on Mac
OS X and Windows. On Linux, defaults to the default display
device.
:rtype: list of `Device`
'''
def get_joysticks(display=None):
'''Get a list of attached joysticks.
:Parameters:
`display` : `Display`
The display device to query for input devices. Ignored on Mac
OS X and Windows. On Linux, defaults to the default display
device.
:rtype: list of `Joystick`
'''
def get_tablets(display=None):
'''Get a list of tablets.
This function may return a valid tablet device even if one is not
attached (for example, it is not possible on Mac OS X to determine if
a tablet device is connected). Despite returning a list of tablets,
pyglet does not currently support multiple tablets, and the behaviour
is undefined if more than one is attached.
:Parameters:
`display` : `Display`
The display device to query for input devices. Ignored on Mac
OS X and Windows. On Linux, defaults to the default display
device.
:rtype: list of `Tablet`
'''
else:
def get_tablets(display=None):
return []
from pyglet import compat_platform
if compat_platform.startswith('linux'):
from x11_xinput import get_devices as xinput_get_devices
from x11_xinput_tablet import get_tablets
from evdev import get_devices as evdev_get_devices
from evdev import get_joysticks
def get_devices(display=None):
return (evdev_get_devices(display) +
xinput_get_devices(display))
elif compat_platform in ('cygwin', 'win32'):
from directinput import get_devices, get_joysticks
try:
from wintab import get_tablets
except:
pass
elif compat_platform == 'darwin':
from pyglet import options as pyglet_options
if pyglet_options['darwin_cocoa']:
from darwin_hid import get_devices, get_joysticks, get_apple_remote
else:
from carbon_hid import get_devices, get_joysticks, get_apple_remote
from carbon_tablet import get_tablets
| Python |
#!/usr/bin/env python
'''Event constants from /usr/include/linux/input.h
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
EV_SYN = 0x00
EV_KEY = 0x01
EV_REL = 0x02
EV_ABS = 0x03
EV_MSC = 0x04
EV_LED = 0x11
EV_SND = 0x12
EV_REP = 0x14
EV_FF = 0x15
EV_PWR = 0x16
EV_FF_STATUS = 0x17
EV_MAX = 0x1f
# Synchronization events.
SYN_REPORT = 0
SYN_CONFIG = 1
# Keys and buttons
KEY_RESERVED = 0
KEY_ESC = 1
KEY_1 = 2
KEY_2 = 3
KEY_3 = 4
KEY_4 = 5
KEY_5 = 6
KEY_6 = 7
KEY_7 = 8
KEY_8 = 9
KEY_9 = 10
KEY_0 = 11
KEY_MINUS = 12
KEY_EQUAL = 13
KEY_BACKSPACE = 14
KEY_TAB = 15
KEY_Q = 16
KEY_W = 17
KEY_E = 18
KEY_R = 19
KEY_T = 20
KEY_Y = 21
KEY_U = 22
KEY_I = 23
KEY_O = 24
KEY_P = 25
KEY_LEFTBRACE = 26
KEY_RIGHTBRACE = 27
KEY_ENTER = 28
KEY_LEFTCTRL = 29
KEY_A = 30
KEY_S = 31
KEY_D = 32
KEY_F = 33
KEY_G = 34
KEY_H = 35
KEY_J = 36
KEY_K = 37
KEY_L = 38
KEY_SEMICOLON = 39
KEY_APOSTROPHE = 40
KEY_GRAVE = 41
KEY_LEFTSHIFT = 42
KEY_BACKSLASH = 43
KEY_Z = 44
KEY_X = 45
KEY_C = 46
KEY_V = 47
KEY_B = 48
KEY_N = 49
KEY_M = 50
KEY_COMMA = 51
KEY_DOT = 52
KEY_SLASH = 53
KEY_RIGHTSHIFT = 54
KEY_KPASTERISK = 55
KEY_LEFTALT = 56
KEY_SPACE = 57
KEY_CAPSLOCK = 58
KEY_F1 = 59
KEY_F2 = 60
KEY_F3 = 61
KEY_F4 = 62
KEY_F5 = 63
KEY_F6 = 64
KEY_F7 = 65
KEY_F8 = 66
KEY_F9 = 67
KEY_F10 = 68
KEY_NUMLOCK = 69
KEY_SCROLLLOCK = 70
KEY_KP7 = 71
KEY_KP8 = 72
KEY_KP9 = 73
KEY_KPMINUS = 74
KEY_KP4 = 75
KEY_KP5 = 76
KEY_KP6 = 77
KEY_KPPLUS = 78
KEY_KP1 = 79
KEY_KP2 = 80
KEY_KP3 = 81
KEY_KP0 = 82
KEY_KPDOT = 83
KEY_ZENKAKUHANKAKU = 85
KEY_102ND = 86
KEY_F11 = 87
KEY_F12 = 88
KEY_RO = 89
KEY_KATAKANA = 90
KEY_HIRAGANA = 91
KEY_HENKAN = 92
KEY_KATAKANAHIRAGANA = 93
KEY_MUHENKAN = 94
KEY_KPJPCOMMA = 95
KEY_KPENTER = 96
KEY_RIGHTCTRL = 97
KEY_KPSLASH = 98
KEY_SYSRQ = 99
KEY_RIGHTALT = 100
KEY_LINEFEED = 101
KEY_HOME = 102
KEY_UP = 103
KEY_PAGEUP = 104
KEY_LEFT = 105
KEY_RIGHT = 106
KEY_END = 107
KEY_DOWN = 108
KEY_PAGEDOWN = 109
KEY_INSERT = 110
KEY_DELETE = 111
KEY_MACRO = 112
KEY_MUTE = 113
KEY_VOLUMEDOWN = 114
KEY_VOLUMEUP = 115
KEY_POWER = 116
KEY_KPEQUAL = 117
KEY_KPPLUSMINUS = 118
KEY_PAUSE = 119
KEY_KPCOMMA = 121
KEY_HANGUEL = 122
KEY_HANJA = 123
KEY_YEN = 124
KEY_LEFTMETA = 125
KEY_RIGHTMETA = 126
KEY_COMPOSE = 127
KEY_STOP = 128
KEY_AGAIN = 129
KEY_PROPS = 130
KEY_UNDO = 131
KEY_FRONT = 132
KEY_COPY = 133
KEY_OPEN = 134
KEY_PASTE = 135
KEY_FIND = 136
KEY_CUT = 137
KEY_HELP = 138
KEY_MENU = 139
KEY_CALC = 140
KEY_SETUP = 141
KEY_SLEEP = 142
KEY_WAKEUP = 143
KEY_FILE = 144
KEY_SENDFILE = 145
KEY_DELETEFILE = 146
KEY_XFER = 147
KEY_PROG1 = 148
KEY_PROG2 = 149
KEY_WWW = 150
KEY_MSDOS = 151
KEY_COFFEE = 152
KEY_DIRECTION = 153
KEY_CYCLEWINDOWS = 154
KEY_MAIL = 155
KEY_BOOKMARKS = 156
KEY_COMPUTER = 157
KEY_BACK = 158
KEY_FORWARD = 159
KEY_CLOSECD = 160
KEY_EJECTCD = 161
KEY_EJECTCLOSECD = 162
KEY_NEXTSONG = 163
KEY_PLAYPAUSE = 164
KEY_PREVIOUSSONG = 165
KEY_STOPCD = 166
KEY_RECORD = 167
KEY_REWIND = 168
KEY_PHONE = 169
KEY_ISO = 170
KEY_CONFIG = 171
KEY_HOMEPAGE = 172
KEY_REFRESH = 173
KEY_EXIT = 174
KEY_MOVE = 175
KEY_EDIT = 176
KEY_SCROLLUP = 177
KEY_SCROLLDOWN = 178
KEY_KPLEFTPAREN = 179
KEY_KPRIGHTPAREN = 180
KEY_F13 = 183
KEY_F14 = 184
KEY_F15 = 185
KEY_F16 = 186
KEY_F17 = 187
KEY_F18 = 188
KEY_F19 = 189
KEY_F20 = 190
KEY_F21 = 191
KEY_F22 = 192
KEY_F23 = 193
KEY_F24 = 194
KEY_PLAYCD = 200
KEY_PAUSECD = 201
KEY_PROG3 = 202
KEY_PROG4 = 203
KEY_SUSPEND = 205
KEY_CLOSE = 206
KEY_PLAY = 207
KEY_FASTFORWARD = 208
KEY_BASSBOOST = 209
KEY_PRINT = 210
KEY_HP = 211
KEY_CAMERA = 212
KEY_SOUND = 213
KEY_QUESTION = 214
KEY_EMAIL = 215
KEY_CHAT = 216
KEY_SEARCH = 217
KEY_CONNECT = 218
KEY_FINANCE = 219
KEY_SPORT = 220
KEY_SHOP = 221
KEY_ALTERASE = 222
KEY_CANCEL = 223
KEY_BRIGHTNESSDOWN = 224
KEY_BRIGHTNESSUP = 225
KEY_MEDIA = 226
KEY_UNKNOWN = 240
BTN_MISC = 0x100
BTN_0 = 0x100
BTN_1 = 0x101
BTN_2 = 0x102
BTN_3 = 0x103
BTN_4 = 0x104
BTN_5 = 0x105
BTN_6 = 0x106
BTN_7 = 0x107
BTN_8 = 0x108
BTN_9 = 0x109
BTN_MOUSE = 0x110
BTN_LEFT = 0x110
BTN_RIGHT = 0x111
BTN_MIDDLE = 0x112
BTN_SIDE = 0x113
BTN_EXTRA = 0x114
BTN_FORWARD = 0x115
BTN_BACK = 0x116
BTN_TASK = 0x117
BTN_JOYSTICK = 0x120
BTN_TRIGGER = 0x120
BTN_THUMB = 0x121
BTN_THUMB2 = 0x122
BTN_TOP = 0x123
BTN_TOP2 = 0x124
BTN_PINKIE = 0x125
BTN_BASE = 0x126
BTN_BASE2 = 0x127
BTN_BASE3 = 0x128
BTN_BASE4 = 0x129
BTN_BASE5 = 0x12a
BTN_BASE6 = 0x12b
BTN_DEAD = 0x12f
BTN_GAMEPAD = 0x130
BTN_A = 0x130
BTN_B = 0x131
BTN_C = 0x132
BTN_X = 0x133
BTN_Y = 0x134
BTN_Z = 0x135
BTN_TL = 0x136
BTN_TR = 0x137
BTN_TL2 = 0x138
BTN_TR2 = 0x139
BTN_SELECT = 0x13a
BTN_START = 0x13b
BTN_MODE = 0x13c
BTN_THUMBL = 0x13d
BTN_THUMBR = 0x13e
BTN_DIGI = 0x140
BTN_TOOL_PEN = 0x140
BTN_TOOL_RUBBER = 0x141
BTN_TOOL_BRUSH = 0x142
BTN_TOOL_PENCIL = 0x143
BTN_TOOL_AIRBRUSH = 0x144
BTN_TOOL_FINGER = 0x145
BTN_TOOL_MOUSE = 0x146
BTN_TOOL_LENS = 0x147
BTN_TOUCH = 0x14a
BTN_STYLUS = 0x14b
BTN_STYLUS2 = 0x14c
BTN_TOOL_DOUBLETAP = 0x14d
BTN_TOOL_TRIPLETAP = 0x14e
BTN_WHEEL = 0x150
BTN_GEAR_DOWN = 0x150
BTN_GEAR_UP = 0x151
KEY_OK = 0x160
KEY_SELECT = 0x161
KEY_GOTO = 0x162
KEY_CLEAR = 0x163
KEY_POWER2 = 0x164
KEY_OPTION = 0x165
KEY_INFO = 0x166
KEY_TIME = 0x167
KEY_VENDOR = 0x168
KEY_ARCHIVE = 0x169
KEY_PROGRAM = 0x16a
KEY_CHANNEL = 0x16b
KEY_FAVORITES = 0x16c
KEY_EPG = 0x16d
KEY_PVR = 0x16e
KEY_MHP = 0x16f
KEY_LANGUAGE = 0x170
KEY_TITLE = 0x171
KEY_SUBTITLE = 0x172
KEY_ANGLE = 0x173
KEY_ZOOM = 0x174
KEY_MODE = 0x175
KEY_KEYBOARD = 0x176
KEY_SCREEN = 0x177
KEY_PC = 0x178
KEY_TV = 0x179
KEY_TV2 = 0x17a
KEY_VCR = 0x17b
KEY_VCR2 = 0x17c
KEY_SAT = 0x17d
KEY_SAT2 = 0x17e
KEY_CD = 0x17f
KEY_TAPE = 0x180
KEY_RADIO = 0x181
KEY_TUNER = 0x182
KEY_PLAYER = 0x183
KEY_TEXT = 0x184
KEY_DVD = 0x185
KEY_AUX = 0x186
KEY_MP3 = 0x187
KEY_AUDIO = 0x188
KEY_VIDEO = 0x189
KEY_DIRECTORY = 0x18a
KEY_LIST = 0x18b
KEY_MEMO = 0x18c
KEY_CALENDAR = 0x18d
KEY_RED = 0x18e
KEY_GREEN = 0x18f
KEY_YELLOW = 0x190
KEY_BLUE = 0x191
KEY_CHANNELUP = 0x192
KEY_CHANNELDOWN = 0x193
KEY_FIRST = 0x194
KEY_LAST = 0x195
KEY_AB = 0x196
KEY_NEXT = 0x197
KEY_RESTART = 0x198
KEY_SLOW = 0x199
KEY_SHUFFLE = 0x19a
KEY_BREAK = 0x19b
KEY_PREVIOUS = 0x19c
KEY_DIGITS = 0x19d
KEY_TEEN = 0x19e
KEY_TWEN = 0x19f
KEY_DEL_EOL = 0x1c0
KEY_DEL_EOS = 0x1c1
KEY_INS_LINE = 0x1c2
KEY_DEL_LINE = 0x1c3
KEY_FN = 0x1d0
KEY_FN_ESC = 0x1d1
KEY_FN_F1 = 0x1d2
KEY_FN_F2 = 0x1d3
KEY_FN_F3 = 0x1d4
KEY_FN_F4 = 0x1d5
KEY_FN_F5 = 0x1d6
KEY_FN_F6 = 0x1d7
KEY_FN_F7 = 0x1d8
KEY_FN_F8 = 0x1d9
KEY_FN_F9 = 0x1da
KEY_FN_F10 = 0x1db
KEY_FN_F11 = 0x1dc
KEY_FN_F12 = 0x1dd
KEY_FN_1 = 0x1de
KEY_FN_2 = 0x1df
KEY_FN_D = 0x1e0
KEY_FN_E = 0x1e1
KEY_FN_F = 0x1e2
KEY_FN_S = 0x1e3
KEY_FN_B = 0x1e4
KEY_MAX = 0x1ff
# Relative axes
REL_X = 0x00
REL_Y = 0x01
REL_Z = 0x02
REL_RX = 0x03
REL_RY = 0x04
REL_RZ = 0x05
REL_HWHEEL = 0x06
REL_DIAL = 0x07
REL_WHEEL = 0x08
REL_MISC = 0x09
REL_MAX = 0x0f
# Absolute axes
ABS_X = 0x00
ABS_Y = 0x01
ABS_Z = 0x02
ABS_RX = 0x03
ABS_RY = 0x04
ABS_RZ = 0x05
ABS_THROTTLE = 0x06
ABS_RUDDER = 0x07
ABS_WHEEL = 0x08
ABS_GAS = 0x09
ABS_BRAKE = 0x0a
ABS_HAT0X = 0x10
ABS_HAT0Y = 0x11
ABS_HAT1X = 0x12
ABS_HAT1Y = 0x13
ABS_HAT2X = 0x14
ABS_HAT2Y = 0x15
ABS_HAT3X = 0x16
ABS_HAT3Y = 0x17
ABS_PRESSURE = 0x18
ABS_DISTANCE = 0x19
ABS_TILT_X = 0x1a
ABS_TILT_Y = 0x1b
ABS_TOOL_WIDTH = 0x1c
ABS_VOLUME = 0x20
ABS_MISC = 0x28
ABS_MAX = 0x3f
# Misc events
MSC_SERIAL = 0x00
MSC_PULSELED = 0x01
MSC_GESTURE = 0x02
MSC_RAW = 0x03
MSC_SCAN = 0x04
MSC_MAX = 0x07
# LEDs
LED_NUML = 0x00
LED_CAPSL = 0x01
LED_SCROLLL = 0x02
LED_COMPOSE = 0x03
LED_KANA = 0x04
LED_SLEEP = 0x05
LED_SUSPEND = 0x06
LED_MUTE = 0x07
LED_MISC = 0x08
LED_MAIL = 0x09
LED_CHARGING = 0x0a
LED_MAX = 0x0f
# Autorepeat values
REP_DELAY = 0x00
REP_PERIOD = 0x01
REP_MAX = 0x01
# Sounds
SND_CLICK = 0x00
SND_BELL = 0x01
SND_TONE = 0x02
SND_MAX = 0x07
# IDs.
ID_BUS = 0
ID_VENDOR = 1
ID_PRODUCT = 2
ID_VERSION = 3
BUS_PCI = 0x01
BUS_ISAPNP = 0x02
BUS_USB = 0x03
BUS_HIL = 0x04
BUS_BLUETOOTH = 0x05
BUS_ISA = 0x10
BUS_I8042 = 0x11
BUS_XTKBD = 0x12
BUS_RS232 = 0x13
BUS_GAMEPORT = 0x14
BUS_PARPORT = 0x15
BUS_AMIGA = 0x16
BUS_ADB = 0x17
BUS_I2C = 0x18
BUS_HOST = 0x19
# Values describing the status of an effect
FF_STATUS_STOPPED = 0x00
FF_STATUS_PLAYING = 0x01
FF_STATUS_MAX = 0x01
_rel_raw_names = {}
_abs_raw_names = {}
_key_raw_names = {}
for _name, _val in locals().copy().items():
if _name.startswith('REL_'):
_rel_raw_names[_val] = _name
elif _name.startswith('ABS_'):
_abs_raw_names[_val] = _name
elif _name.startswith('KEY_') or _name.startswith('BTN_'):
_key_raw_names[_val] = _name
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Get environment information useful for debugging.
Intended usage is to create a file for bug reports, e.g.::
python -m pyglet.info > info.txt
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
_first_heading = True
def _heading(heading):
global _first_heading
if not _first_heading:
print
else:
_first_heading = False
print heading
print '-' * 78
def dump_python():
'''Dump Python version and environment to stdout.'''
import os
import sys
print 'sys.version:', sys.version
print 'sys.platform:', sys.platform
print 'sys.maxint:', sys.maxint
if sys.platform == 'darwin':
try:
from objc import __version__ as pyobjc_version
print 'objc.__version__:', pyobjc_version
except:
print 'PyObjC not available'
print 'os.getcwd():', os.getcwd()
for key, value in os.environ.items():
if key.startswith('PYGLET_'):
print "os.environ['%s']: %s" % (key, value)
def dump_pyglet():
'''Dump pyglet version and options.'''
import pyglet
print 'pyglet.version:', pyglet.version
print 'pyglet.compat_platform:', pyglet.compat_platform
print 'pyglet.__file__:', pyglet.__file__
for key, value in pyglet.options.items():
print "pyglet.options['%s'] = %r" % (key, value)
def dump_window():
'''Dump display, window, screen and default config info.'''
import pyglet.window
platform = pyglet.window.get_platform()
print 'platform:', repr(platform)
display = platform.get_default_display()
print 'display:', repr(display)
screens = display.get_screens()
for i, screen in enumerate(screens):
print 'screens[%d]: %r' % (i, screen)
window = pyglet.window.Window(visible=False)
for key, value in window.config.get_gl_attributes():
print "config['%s'] = %r" % (key, value)
print 'context:', repr(window.context)
_heading('window.context._info')
dump_gl(window.context)
window.close()
def dump_gl(context=None):
'''Dump GL info.'''
if context is not None:
info = context.get_info()
else:
from pyglet.gl import gl_info as info
print 'gl_info.get_version():', info.get_version()
print 'gl_info.get_vendor():', info.get_vendor()
print 'gl_info.get_renderer():', info.get_renderer()
print 'gl_info.get_extensions():'
extensions = list(info.get_extensions())
extensions.sort()
for name in extensions:
print ' ', name
def dump_glu():
'''Dump GLU info.'''
from pyglet.gl import glu_info
print 'glu_info.get_version():', glu_info.get_version()
print 'glu_info.get_extensions():'
extensions = list(glu_info.get_extensions())
extensions.sort()
for name in extensions:
print ' ', name
def dump_glx():
'''Dump GLX info.'''
try:
from pyglet.gl import glx_info
except:
print 'GLX not available.'
return
import pyglet
window = pyglet.window.Window(visible=False)
print 'context.is_direct():', window.context.is_direct()
window.close()
if not glx_info.have_version(1, 1):
print 'Version: < 1.1'
else:
print 'glx_info.get_server_vendor():', glx_info.get_server_vendor()
print 'glx_info.get_server_version():', glx_info.get_server_version()
print 'glx_info.get_server_extensions():'
for name in glx_info.get_server_extensions():
print ' ', name
print 'glx_info.get_client_vendor():', glx_info.get_client_vendor()
print 'glx_info.get_client_version():', glx_info.get_client_version()
print 'glx_info.get_client_extensions():'
for name in glx_info.get_client_extensions():
print ' ', name
print 'glx_info.get_extensions():'
for name in glx_info.get_extensions():
print ' ', name
def dump_media():
'''Dump pyglet.media info.'''
import pyglet.media
print 'audio driver:', pyglet.media.get_audio_driver()
def dump_avbin():
'''Dump AVbin info.'''
try:
import pyglet.media.avbin
print 'Library:', pyglet.media.avbin.av
print 'AVbin version:', pyglet.media.avbin.av.avbin_get_version()
print 'FFmpeg revision:', \
pyglet.media.avbin.av.avbin_get_ffmpeg_revision()
except:
print 'AVbin not available.'
def dump_al():
'''Dump OpenAL info.'''
try:
from pyglet.media.drivers import openal
except:
print 'OpenAL not available.'
return
print 'Library:', openal.al._lib
driver = openal.create_audio_driver()
print 'Version:', driver.get_version()
print 'Extensions:'
for extension in driver.get_extensions():
print ' ', extension
def dump_wintab():
'''Dump WinTab info.'''
try:
from pyglet.input import wintab
except:
print 'WinTab not available.'
return
interface_name = wintab.get_interface_name()
impl_version = wintab.get_implementation_version()
spec_version = wintab.get_spec_version()
print 'WinTab: %s %d.%d (Spec %d.%d)' % (interface_name,
impl_version >> 8, impl_version & 0xff,
spec_version >> 8, spec_version & 0xff)
def _try_dump(heading, func):
_heading(heading)
try:
func()
except:
import traceback
traceback.print_exc()
def dump():
'''Dump all information to stdout.'''
_try_dump('Python', dump_python)
_try_dump('pyglet', dump_pyglet)
_try_dump('pyglet.window', dump_window)
_try_dump('pyglet.gl.glu_info', dump_glu)
_try_dump('pyglet.gl.glx_info', dump_glx)
_try_dump('pyglet.media', dump_media)
_try_dump('pyglet.media.avbin', dump_avbin)
_try_dump('pyglet.media.drivers.openal', dump_al)
_try_dump('pyglet.input.wintab', dump_wintab)
if __name__ == '__main__':
dump()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Event dispatch framework.
All objects that produce events in pyglet implement `EventDispatcher`,
providing a consistent interface for registering and manipulating event
handlers. A commonly used event dispatcher is `pyglet.window.Window`.
Event types
===========
For each event dispatcher there is a set of events that it dispatches; these
correspond with the type of event handlers you can attach. Event types are
identified by their name, for example, ''on_resize''. If you are creating a
new class which implements `EventDispatcher`, you must call
`EventDispatcher.register_event_type` for each event type.
Attaching event handlers
========================
An event handler is simply a function or method. You can attach an event
handler by setting the appropriate function on the instance::
def on_resize(width, height):
# ...
dispatcher.on_resize = on_resize
There is also a convenience decorator that reduces typing::
@dispatcher.event
def on_resize(width, height):
# ...
You may prefer to subclass and override the event handlers instead::
class MyDispatcher(DispatcherClass):
def on_resize(self, width, height):
# ...
Event handler stack
===================
When attaching an event handler to a dispatcher using the above methods, it
replaces any existing handler (causing the original handler to no longer be
called). Each dispatcher maintains a stack of event handlers, allowing you to
insert an event handler "above" the existing one rather than replacing it.
There are two main use cases for "pushing" event handlers:
* Temporarily intercepting the events coming from the dispatcher by pushing a
custom set of handlers onto the dispatcher, then later "popping" them all
off at once.
* Creating "chains" of event handlers, where the event propagates from the
top-most (most recently added) handler to the bottom, until a handler
takes care of it.
Use `EventDispatcher.push_handlers` to create a new level in the stack and
attach handlers to it. You can push several handlers at once::
dispatcher.push_handlers(on_resize, on_key_press)
If your function handlers have different names to the events they handle, use
keyword arguments::
dispatcher.push_handlers(on_resize=my_resize,
on_key_press=my_key_press)
After an event handler has processed an event, it is passed on to the
next-lowest event handler, unless the handler returns `EVENT_HANDLED`, which
prevents further propagation.
To remove all handlers on the top stack level, use
`EventDispatcher.pop_handlers`.
Note that any handlers pushed onto the stack have precedence over the
handlers set directly on the instance (for example, using the methods
described in the previous section), regardless of when they were set.
For example, handler ``foo`` is called before handler ``bar`` in the following
example::
dispatcher.push_handlers(on_resize=foo)
dispatcher.on_resize = bar
Dispatching events
==================
pyglet uses a single-threaded model for all application code. Event
handlers are only ever invoked as a result of calling
EventDispatcher.dispatch_events`.
It is up to the specific event dispatcher to queue relevant events until they
can be dispatched, at which point the handlers are called in the order the
events were originally generated.
This implies that your application runs with a main loop that continuously
updates the application state and checks for new events::
while True:
dispatcher.dispatch_events()
# ... additional per-frame processing
Not all event dispatchers require the call to ``dispatch_events``; check with
the particular class documentation.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import inspect
EVENT_HANDLED = True
EVENT_UNHANDLED = None
class EventException(Exception):
'''An exception raised when an event handler could not be attached.
'''
pass
class EventDispatcher(object):
'''Generic event dispatcher interface.
See the module docstring for usage.
'''
# Placeholder empty stack; real stack is created only if needed
_event_stack = ()
@classmethod
def register_event_type(cls, name):
'''Register an event type with the dispatcher.
Registering event types allows the dispatcher to validate event
handler names as they are attached, and to search attached objects for
suitable handlers.
:Parameters:
`name` : str
Name of the event to register.
'''
if not hasattr(cls, 'event_types'):
cls.event_types = []
cls.event_types.append(name)
return name
def push_handlers(self, *args, **kwargs):
'''Push a level onto the top of the handler stack, then attach zero or
more event handlers.
If keyword arguments are given, they name the event type to attach.
Otherwise, a callable's `__name__` attribute will be used. Any other
object may also be specified, in which case it will be searched for
callables with event names.
'''
# Create event stack if necessary
if type(self._event_stack) is tuple:
self._event_stack = []
# Place dict full of new handlers at beginning of stack
self._event_stack.insert(0, {})
self.set_handlers(*args, **kwargs)
def _get_handlers(self, args, kwargs):
'''Implement handler matching on arguments for set_handlers and
remove_handlers.
'''
for object in args:
if inspect.isroutine(object):
# Single magically named function
name = object.__name__
if name not in self.event_types:
raise EventException('Unknown event "%s"' % name)
yield name, object
else:
# Single instance with magically named methods
for name in dir(object):
if name in self.event_types:
yield name, getattr(object, name)
for name, handler in kwargs.items():
# Function for handling given event (no magic)
if name not in self.event_types:
raise EventException('Unknown event "%s"' % name)
yield name, handler
def set_handlers(self, *args, **kwargs):
'''Attach one or more event handlers to the top level of the handler
stack.
See `push_handlers` for the accepted argument types.
'''
# Create event stack if necessary
if type(self._event_stack) is tuple:
self._event_stack = [{}]
for name, handler in self._get_handlers(args, kwargs):
self.set_handler(name, handler)
def set_handler(self, name, handler):
'''Attach a single event handler.
:Parameters:
`name` : str
Name of the event type to attach to.
`handler` : callable
Event handler to attach.
'''
# Create event stack if necessary
if type(self._event_stack) is tuple:
self._event_stack = [{}]
self._event_stack[0][name] = handler
def pop_handlers(self):
'''Pop the top level of event handlers off the stack.
'''
assert self._event_stack and 'No handlers pushed'
del self._event_stack[0]
def remove_handlers(self, *args, **kwargs):
'''Remove event handlers from the event stack.
See `push_handlers` for the accepted argument types. All handlers
are removed from the first stack frame that contains any of the given
handlers. No error is raised if any handler does not appear in that
frame, or if no stack frame contains any of the given handlers.
If the stack frame is empty after removing the handlers, it is
removed from the stack. Note that this interferes with the expected
symmetry of `push_handlers` and `pop_handlers`.
'''
handlers = list(self._get_handlers(args, kwargs))
# Find the first stack frame containing any of the handlers
def find_frame():
for frame in self._event_stack:
for name, handler in handlers:
try:
if frame[name] == handler:
return frame
except KeyError:
pass
frame = find_frame()
# No frame matched; no error.
if not frame:
return
# Remove each handler from the frame.
for name, handler in handlers:
try:
if frame[name] == handler:
del frame[name]
except KeyError:
pass
# Remove the frame if it's empty.
if not frame:
self._event_stack.remove(frame)
def remove_handler(self, name, handler):
'''Remove a single event handler.
The given event handler is removed from the first handler stack frame
it appears in. The handler must be the exact same callable as passed
to `set_handler`, `set_handlers` or `push_handlers`; and the name
must match the event type it is bound to.
No error is raised if the event handler is not set.
:Parameters:
`name` : str
Name of the event type to remove.
`handler` : callable
Event handler to remove.
'''
for frame in self._event_stack:
try:
if frame[name] == handler:
del frame[name]
break
except KeyError:
pass
def dispatch_event(self, event_type, *args):
'''Dispatch a single event to the attached handlers.
The event is propagated to all handlers from from the top of the stack
until one returns `EVENT_HANDLED`. This method should be used only by
`EventDispatcher` implementors; applications should call
the ``dispatch_events`` method.
Since pyglet 1.2, the method returns `EVENT_HANDLED` if an event
handler returned `EVENT_HANDLED` or `EVENT_UNHANDLED` if all events
returned `EVENT_UNHANDLED`. If no matching event handlers are in the
stack, ``False`` is returned.
:Parameters:
`event_type` : str
Name of the event.
`args` : sequence
Arguments to pass to the event handler.
:rtype: bool or None
:return: (Since pyglet 1.2) `EVENT_HANDLED` if an event handler
returned `EVENT_HANDLED`; `EVENT_UNHANDLED` if one or more event
handlers were invoked but returned only `EVENT_UNHANDLED`;
otherwise ``False``. In pyglet 1.1 and earler, the return value
is always ``None``.
'''
assert event_type in self.event_types, "%r not found in %r.event_types == %r" % (event_type, self, self.event_types)
invoked = False
# Search handler stack for matching event handlers
for frame in list(self._event_stack):
handler = frame.get(event_type, None)
if handler:
try:
invoked = True
if handler(*args):
return EVENT_HANDLED
except TypeError:
self._raise_dispatch_exception(event_type, args, handler)
# Check instance for an event handler
if hasattr(self, event_type):
try:
invoked = True
if getattr(self, event_type)(*args):
return EVENT_HANDLED
except TypeError:
self._raise_dispatch_exception(
event_type, args, getattr(self, event_type))
if invoked:
return EVENT_UNHANDLED
return False
def _raise_dispatch_exception(self, event_type, args, handler):
# A common problem in applications is having the wrong number of
# arguments in an event handler. This is caught as a TypeError in
# dispatch_event but the error message is obfuscated.
#
# Here we check if there is indeed a mismatch in argument count,
# and construct a more useful exception message if so. If this method
# doesn't find a problem with the number of arguments, the error
# is re-raised as if we weren't here.
n_args = len(args)
# Inspect the handler
handler_args, handler_varargs, _, handler_defaults = \
inspect.getargspec(handler)
n_handler_args = len(handler_args)
# Remove "self" arg from handler if it's a bound method
if inspect.ismethod(handler) and handler.im_self:
n_handler_args -= 1
# Allow *args varargs to overspecify arguments
if handler_varargs:
n_handler_args = max(n_handler_args, n_args)
# Allow default values to overspecify arguments
if (n_handler_args > n_args and
handler_defaults and
n_handler_args - len(handler_defaults) <= n_args):
n_handler_args = n_args
if n_handler_args != n_args:
if inspect.isfunction(handler) or inspect.ismethod(handler):
descr = '%s at %s:%d' % (
handler.func_name,
handler.func_code.co_filename,
handler.func_code.co_firstlineno)
else:
descr = repr(handler)
raise TypeError(
'%s event was dispatched with %d arguments, but '
'handler %s has an incompatible function signature' %
(event_type, len(args), descr))
else:
raise
def event(self, *args):
'''Function decorator for an event handler.
Usage::
win = window.Window()
@win.event
def on_resize(self, width, height):
# ...
or::
@win.event('on_resize')
def foo(self, width, height):
# ...
'''
if len(args) == 0: # @window.event()
def decorator(func):
name = func.__name__
self.set_handler(name, func)
return func
return decorator
elif inspect.isroutine(args[0]): # @window.event
func = args[0]
name = func.__name__
self.set_handler(name, func)
return args[0]
elif type(args[0]) in (str, unicode): # @window.event('on_resize')
name = args[0]
def decorator(func):
self.set_handler(name, func)
return func
return decorator
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import os
import select
import threading
from ctypes import *
from pyglet import app
from pyglet.app.base import PlatformEventLoop
from pyglet.compat import asbytes
class XlibSelectDevice(object):
def fileno(self):
'''Get the file handle for ``select()`` for this device.
:rtype: int
'''
raise NotImplementedError('abstract')
def select(self):
'''Perform event processing on the device.
Called when ``select()`` returns this device in its list of active
files.
'''
raise NotImplementedError('abstract')
def poll(self):
'''Check if the device has events ready to process.
:rtype: bool
:return: True if there are events to process, False otherwise.
'''
return False
class NotificationDevice(XlibSelectDevice):
def __init__(self):
self._sync_file_read, self._sync_file_write = os.pipe()
self._event = threading.Event()
def fileno(self):
return self._sync_file_read
def set(self):
self._event.set()
os.write(self._sync_file_write, asbytes('1'))
def select(self):
self._event.clear()
os.read(self._sync_file_read, 1)
app.platform_event_loop.dispatch_posted_events()
def poll(self):
return self._event.isSet()
class XlibEventLoop(PlatformEventLoop):
def __init__(self):
super(XlibEventLoop, self).__init__()
self._notification_device = NotificationDevice()
self._select_devices = set()
self._select_devices.add(self._notification_device)
def notify(self):
self._notification_device.set()
def step(self, timeout=None):
pending_devices = []
# Check for already pending events
for device in self._select_devices:
if device.poll():
pending_devices.append(device)
# If nothing was immediately pending, block until there's activity
# on a device.
if not pending_devices and (timeout is None or timeout > 0.0):
iwtd = self._select_devices
pending_devices, _, _ = select.select(iwtd, (), (), timeout)
if not pending_devices:
return False
# Dispatch activity on matching devices
for device in pending_devices:
device.select()
# Dispatch resize events
for window in app.windows:
if window._needs_resize:
window.switch_to()
window.dispatch_event('on_resize',
window._width, window._height)
window.dispatch_event('on_expose')
window._needs_resize = False
return True
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from pyglet.app.base import PlatformEventLoop
from pyglet.libs.darwin.cocoapy import *
NSApplication = ObjCClass('NSApplication')
NSMenu = ObjCClass('NSMenu')
NSMenuItem = ObjCClass('NSMenuItem')
NSAutoreleasePool = ObjCClass('NSAutoreleasePool')
NSDate = ObjCClass('NSDate')
NSEvent = ObjCClass('NSEvent')
NSUserDefaults = ObjCClass('NSUserDefaults')
def add_menu_item(menu, title, action, key):
title = CFSTR(title)
action = get_selector(action)
key = CFSTR(key)
menuItem = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
title, action, key)
menu.addItem_(menuItem)
# cleanup
title.release()
key.release()
menuItem.release()
def create_menu():
appMenu = NSMenu.alloc().init()
# Hide still doesn't work!?
add_menu_item(appMenu, 'Hide!', 'hide:', 'h')
appMenu.addItem_(NSMenuItem.separatorItem())
add_menu_item(appMenu, 'Quit!', 'terminate:', 'q')
menubar = NSMenu.alloc().init()
appMenuItem = NSMenuItem.alloc().init()
appMenuItem.setSubmenu_(appMenu)
menubar.addItem_(appMenuItem)
NSApp = NSApplication.sharedApplication()
NSApp.setMainMenu_(menubar)
# cleanup
appMenu.release()
menubar.release()
appMenuItem.release()
class CocoaEventLoop(PlatformEventLoop):
def __init__(self):
super(CocoaEventLoop, self).__init__()
# Prepare the default application.
self.NSApp = NSApplication.sharedApplication()
# Create an autorelease pool for menu creation and finishLaunching
self.pool = NSAutoreleasePool.alloc().init()
create_menu()
self.NSApp.setActivationPolicy_(NSApplicationActivationPolicyRegular)
# Prevent Lion / Mountain Lion from automatically saving application state.
# If we don't do this, new windows will not display on 10.8 after finishLaunching
# has been called.
defaults = NSUserDefaults.standardUserDefaults()
ignoreState = CFSTR("ApplePersistenceIgnoreState")
if not defaults.objectForKey_(ignoreState):
defaults.setBool_forKey_(True, ignoreState)
def start(self):
self.NSApp.finishLaunching()
self.NSApp.activateIgnoringOtherApps_(True)
def step(self, timeout=None):
# Drain the old autorelease pool
self.pool.drain()
self.pool = NSAutoreleasePool.alloc().init()
self.dispatch_posted_events()
# Determine the timeout date.
if timeout is None:
# Using distantFuture as untilDate means that nextEventMatchingMask
# will wait until the next event comes along.
timeout_date = NSDate.distantFuture()
else:
timeout_date = NSDate.dateWithTimeIntervalSinceNow_(timeout)
# Retrieve the next event (if any). We wait for an event to show up
# and then process it, or if timeout_date expires we simply return.
# We only process one event per call of step().
self._is_running.set()
event = self.NSApp.nextEventMatchingMask_untilDate_inMode_dequeue_(
NSAnyEventMask, timeout_date, NSDefaultRunLoopMode, True)
# Dispatch the event (if any).
if event is not None:
event_type = event.type()
if event_type != NSApplicationDefined:
# Send out event as normal. Responders will still receive
# keyUp:, keyDown:, and flagsChanged: events.
self.NSApp.sendEvent_(event)
# Resend key events as special pyglet-specific messages
# which supplant the keyDown:, keyUp:, and flagsChanged: messages
# because NSApplication translates multiple key presses into key
# equivalents before sending them on, which means that some keyUp:
# messages are never sent for individual keys. Our pyglet-specific
# replacements ensure that we see all the raw key presses & releases.
# We also filter out key-down repeats since pyglet only sends one
# on_key_press event per key press.
if event_type == NSKeyDown and not event.isARepeat():
self.NSApp.sendAction_to_from_(get_selector("pygletKeyDown:"), None, event)
elif event_type == NSKeyUp:
self.NSApp.sendAction_to_from_(get_selector("pygletKeyUp:"), None, event)
elif event_type == NSFlagsChanged:
self.NSApp.sendAction_to_from_(get_selector("pygletFlagsChanged:"), None, event)
self.NSApp.updateWindows()
did_time_out = False
else:
did_time_out = True
self._is_running.clear()
# Destroy the autorelease pool used for this step.
#del pool
return did_time_out
def stop(self):
pass
def notify(self):
pool = NSAutoreleasePool.alloc().init()
notifyEvent = NSEvent.otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_(
NSApplicationDefined, # type
NSPoint(0.0, 0.0), # location
0, # modifierFlags
0, # timestamp
0, # windowNumber
None, # graphicsContext
0, # subtype
0, # data1
0, # data2
)
self.NSApp.postEvent_atStart_(notifyEvent, False)
pool.drain()
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import sys
import threading
import Queue
from pyglet import app
from pyglet import clock
from pyglet import event
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
class PlatformEventLoop(object):
''' Abstract class, implementation depends on platform.
:since: pyglet 1.2
'''
def __init__(self):
self._event_queue = Queue.Queue()
self._is_running = threading.Event()
self._is_running.clear()
def is_running(self):
'''Return True if the event loop is currently processing, or False
if it is blocked or not activated.
:rtype: bool
'''
return self._is_running.is_set()
def post_event(self, dispatcher, event, *args):
'''Post an event into the main application thread.
The event is queued internally until the `run` method's thread
is able to dispatch the event. This method can be safely called
from any thread.
If the method is called from the `run` method's thread (for example,
from within an event handler), the event may be dispatched within
the same runloop iteration or the next one; the choice is
nondeterministic.
:Parameters:
`dispatcher` : EventDispatcher
Dispatcher to process the event.
`event` : str
Event name.
`args` : sequence
Arguments to pass to the event handlers.
'''
self._event_queue.put((dispatcher, event, args))
self.notify()
def dispatch_posted_events(self):
'''Immediately dispatch all pending events.
Normally this is called automatically by the runloop iteration.
'''
while True:
try:
dispatcher, event, args = self._event_queue.get(False)
except Queue.Empty:
break
dispatcher.dispatch_event(event, *args)
def notify(self):
'''Notify the event loop that something needs processing.
If the event loop is blocked, it will unblock and perform an iteration
immediately. If the event loop is running, another iteration is
scheduled for immediate execution afterwards.
'''
raise NotImplementedError('abstract')
def start(self):
pass
def step(self, timeout=None):
''':TODO: in mac/linux: return True if didn't time out'''
raise NotImplementedError('abstract')
def set_timer(self, func, interval):
raise NotImplementedError('abstract')
def stop(self):
pass
class EventLoop(event.EventDispatcher):
'''The main run loop of the application.
Calling `run` begins the application event loop, which processes
operating system events, calls `pyglet.clock.tick` to call scheduled
functions and calls `pyglet.window.Window.on_draw` and
`pyglet.window.Window.flip` to update window contents.
Applications can subclass `EventLoop` and override certain methods
to integrate another framework's run loop, or to customise processing
in some other way. You should not in general override `run`, as
this method contains platform-specific code that ensures the application
remains responsive to the user while keeping CPU usage to a minimum.
'''
_has_exit_condition = None
_has_exit = False
def __init__(self):
self._has_exit_condition = threading.Condition()
self.clock = clock.get_default()
self.is_running = False
def run(self):
'''Begin processing events, scheduled functions and window updates.
This method returns when `has_exit` is set to True.
Developers are discouraged from overriding this method, as the
implementation is platform-specific.
'''
self.has_exit = False
self._legacy_setup()
platform_event_loop = app.platform_event_loop
platform_event_loop.start()
self.dispatch_event('on_enter')
self.is_running = True
if True: # TODO runtime option.
self._run_estimated()
else:
self._run()
self.is_running = False
self.dispatch_event('on_exit')
platform_event_loop.stop()
def _run(self):
'''The simplest standard run loop, using constant timeout. Suitable
for well-behaving platforms (Mac, Linux and some Windows).
'''
platform_event_loop = app.platform_event_loop
while not self.has_exit:
timeout = self.idle()
platform_event_loop.step(timeout)
def _run_estimated(self):
'''Run-loop that continually estimates function mapping requested
timeout to measured timeout using a least-squares linear regression.
Suitable for oddball platforms (Windows).
'''
platform_event_loop = app.platform_event_loop
predictor = self._least_squares()
gradient, offset = predictor.next()
time = self.clock.time
while not self.has_exit:
timeout = self.idle()
if timeout is None:
estimate = None
else:
estimate = max(gradient * timeout + offset, 0.0)
if False:
print 'Gradient = %f, Offset = %f' % (gradient, offset)
print 'Timeout = %f, Estimate = %f' % (timeout, estimate)
t = time()
if not platform_event_loop.step(estimate) and estimate != 0.0 and \
estimate is not None:
dt = time() - t
gradient, offset = predictor.send((dt, estimate))
@staticmethod
def _least_squares(gradient=1, offset=0):
X = 0
Y = 0
XX = 0
XY = 0
n = 0
x, y = yield gradient, offset
X += x
Y += y
XX += x * x
XY += x * y
n += 1
while True:
x, y = yield gradient, offset
X += x
Y += y
XX += x * x
XY += x * y
n += 1
try:
gradient = (n * XY - X * Y) / (n * XX - X * X)
offset = (Y - gradient * X) / n
except ZeroDivisionError:
# Can happen in pathalogical case; keep current
# gradient/offset for now.
pass
def _legacy_setup(self):
# Disable event queuing for dispatch_events
from pyglet.window import Window
Window._enable_event_queue = False
# Dispatch pending events
for window in app.windows:
window.switch_to()
window.dispatch_pending_events()
def enter_blocking(self):
'''Called by pyglet internal processes when the operating system
is about to block due to a user interaction. For example, this
is common when the user begins resizing or moving a window.
This method provides the event loop with an opportunity to set up
an OS timer on the platform event loop, which will continue to
be invoked during the blocking operation.
The default implementation ensures that `idle` continues to be called
as documented.
:since: pyglet 1.2
'''
timeout = self.idle()
app.platform_event_loop.set_timer(self._blocking_timer, timeout)
def exit_blocking(self):
'''Called by pyglet internal processes when the blocking operation
completes. See `enter_blocking`.
'''
app.platform_event_loop.set_timer(None, None)
def _blocking_timer(self):
timeout = self.idle()
app.platform_event_loop.set_timer(self._blocking_timer, timeout)
def idle(self):
'''Called during each iteration of the event loop.
The method is called immediately after any window events (i.e., after
any user input). The method can return a duration after which
the idle method will be called again. The method may be called
earlier if the user creates more input events. The method
can return `None` to only wait for user events.
For example, return ``1.0`` to have the idle method called every
second, or immediately after any user events.
The default implementation dispatches the
`pyglet.window.Window.on_draw` event for all windows and uses
`pyglet.clock.tick` and `pyglet.clock.get_sleep_time` on the default
clock to determine the return value.
This method should be overridden by advanced users only. To have
code execute at regular intervals, use the
`pyglet.clock.schedule` methods.
:rtype: float
:return: The number of seconds before the idle method should
be called again, or `None` to block for user input.
'''
dt = self.clock.update_time()
redraw_all = self.clock.call_scheduled_functions(dt)
# Redraw all windows
for window in app.windows:
if redraw_all or (window._legacy_invalid and window.invalid):
window.switch_to()
window.dispatch_event('on_draw')
window.flip()
window._legacy_invalid = False
# Update timout
return self.clock.get_sleep_time(True)
def _get_has_exit(self):
self._has_exit_condition.acquire()
result = self._has_exit
self._has_exit_condition.release()
return result
def _set_has_exit(self, value):
self._has_exit_condition.acquire()
self._has_exit = value
self._has_exit_condition.notify()
self._has_exit_condition.release()
has_exit = property(_get_has_exit, _set_has_exit,
doc='''Flag indicating if the event loop will exit in
the next iteration. When set, all waiting threads are interrupted (see
`sleep`).
Thread-safe since pyglet 1.2.
:see: `exit`
:type: bool
''')
def exit(self):
'''Safely exit the event loop at the end of the current iteration.
This method is a thread-safe equivalent for for setting `has_exit` to
``True``. All waiting threads will be interrupted (see
`sleep`).
'''
self._set_has_exit(True)
app.platform_event_loop.notify()
def sleep(self, timeout):
'''Wait for some amount of time, or until the `has_exit` flag is
set or `exit` is called.
This method is thread-safe.
:Parameters:
`timeout` : float
Time to wait, in seconds.
:since: pyglet 1.2
:rtype: bool
:return: ``True`` if the `has_exit` flag is now set, otherwise
``False``.
'''
self._has_exit_condition.acquire()
self._has_exit_condition.wait(timeout)
result = self._has_exit
self._has_exit_condition.release()
return result
def on_window_close(self, window):
'''Default window close handler.'''
if not app.windows:
self.exit()
if _is_epydoc:
def on_window_close(self, window):
'''A window was closed.
This event is dispatched when a window is closed. It is not
dispatched if the window's close button was pressed but the
window did not close.
The default handler calls `exit` if no more windows are open. You
can override this handler to base your application exit on some
other policy.
:event:
'''
def on_enter(self):
'''The event loop is about to begin.
This is dispatched when the event loop is prepared to enter
the main run loop, and represents the last chance for an
application to initialise itself.
:event:
'''
def on_exit(self):
'''The event loop is about to exit.
After dispatching this event, the `run` method returns (the
application may not actually exit if you have more code
following the `run` invocation).
:event:
'''
EventLoop.register_event_type('on_window_close')
EventLoop.register_event_type('on_enter')
EventLoop.register_event_type('on_exit')
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id:$
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import ctypes
from pyglet import app
from base import PlatformEventLoop
from pyglet.libs.win32 import _kernel32, _user32, types, constants
from pyglet.libs.win32.constants import *
from pyglet.libs.win32.types import *
class Win32EventLoop(PlatformEventLoop):
def __init__(self):
super(Win32EventLoop, self).__init__()
self._next_idle_time = None
# Force immediate creation of an event queue on this thread -- note
# that since event loop is created on pyglet.app import, whatever
# imports pyglet.app _must_ own the main run loop.
msg = types.MSG()
_user32.PeekMessageW(ctypes.byref(msg), 0,
constants.WM_USER, constants.WM_USER,
constants.PM_NOREMOVE)
self._event_thread = _kernel32.GetCurrentThreadId()
self._wait_objects = []
self._recreate_wait_objects_array()
self._timer_proc = types.TIMERPROC(self._timer_proc_func)
self._timer = _user32.SetTimer(
0, 0, constants.USER_TIMER_MAXIMUM, self._timer_proc)
def add_wait_object(self, object, func):
self._wait_objects.append((object, func))
self._recreate_wait_objects_array()
def remove_wait_object(self, object):
for i, (_object, _) in enumerate(self._wait_objects):
if object == _object:
del self._wait_objects[i]
break
self._recreate_wait_objects_array()
def _recreate_wait_objects_array(self):
if not self._wait_objects:
self._wait_objects_n = 0
self._wait_objects_array = None
return
self._wait_objects_n = len(self._wait_objects)
self._wait_objects_array = \
(HANDLE * self._wait_objects_n)(*[o for o, f in self._wait_objects])
def start(self):
if _kernel32.GetCurrentThreadId() != self._event_thread:
raise RuntimeError('EventLoop.run() must be called from the same ' +
'thread that imports pyglet.app')
self._timer_func = None
self._polling = False
self._allow_polling = True
def step(self, timeout=None):
self.dispatch_posted_events()
msg = types.MSG()
if timeout is None:
timeout = constants.INFINITE
else:
timeout = int(timeout * 1000) # milliseconds
result = _user32.MsgWaitForMultipleObjects(
self._wait_objects_n,
self._wait_objects_array,
False,
timeout,
constants.QS_ALLINPUT)
result -= constants.WAIT_OBJECT_0
if result == self._wait_objects_n:
while _user32.PeekMessageW(ctypes.byref(msg),
0, 0, 0, constants.PM_REMOVE):
_user32.TranslateMessage(ctypes.byref(msg))
_user32.DispatchMessageW(ctypes.byref(msg))
elif 0 <= result < self._wait_objects_n:
object, func = self._wait_objects[result]
func()
# Return True if timeout was interrupted.
return result <= self._wait_objects_n
def notify(self):
# Nudge the event loop with a message it will discard. Note that only
# user events are actually posted. The posted event will not
# interrupt the window move/size drag loop -- it seems there's no way
# to do this.
_user32.PostThreadMessageW(self._event_thread, constants.WM_USER, 0, 0)
def set_timer(self, func, interval):
if func is None or interval is None:
interval = constants.USER_TIMER_MAXIMUM
else:
interval = int(interval * 1000) # milliseconds
self._timer_func = func
_user32.SetTimer(0, self._timer, interval, self._timer_proc)
def _timer_proc_func(self, hwnd, msg, timer, t):
if self._timer_func:
self._timer_func()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import ctypes
from pyglet import app
from pyglet.app.base import PlatformEventLoop
from pyglet.libs.darwin import *
EventLoopTimerProc = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p)
class CarbonEventLoop(PlatformEventLoop):
def __init__(self):
self._event_loop = carbon.GetMainEventLoop()
self._timer = ctypes.c_void_p()
self._timer_func = None
self._timer_func_proc = EventLoopTimerProc(self._timer_proc)
super(CarbonEventLoop, self).__init__()
def notify(self):
carbon.SetEventLoopTimerNextFireTime(
self._timer, ctypes.c_double(0.0))
def start(self):
# Create timer
timer = self._timer
carbon.InstallEventLoopTimer(self._event_loop,
ctypes.c_double(0.1), #?
ctypes.c_double(kEventDurationForever),
self._timer_func_proc,
None,
ctypes.byref(timer))
def stop(self):
carbon.RemoveEventLoopTimer(self._timer)
def step(self, timeout=None):
self.dispatch_posted_events()
event_dispatcher = carbon.GetEventDispatcherTarget()
e = ctypes.c_void_p()
if timeout is None:
timeout = kEventDurationForever
self._is_running.set()
# XXX should spin on multiple events after first timeout
if carbon.ReceiveNextEvent(0, None, ctypes.c_double(timeout),
True, ctypes.byref(e)) == 0:
carbon.SendEventToEventTarget(e, event_dispatcher)
carbon.ReleaseEvent(e)
timed_out = False
else:
timed_out = True
self._is_running.clear()
return not timed_out
def set_timer(self, func, interval):
if interval is None or func is None:
interval = kEventDurationForever
self._timer_func = func
carbon.SetEventLoopTimerNextFireTime(self._timer,
ctypes.c_double(interval))
def _timer_proc(self, timer, data):
if self._timer_func:
self._timer_func()
'''
self.dispatch_posted_events()
allow_polling = True
for window in app.windows:
# Check for live resizing
if window._resizing is not None:
allow_polling = False
old_width, old_height = window._resizing
rect = Rect()
carbon.GetWindowBounds(window._window,
kWindowContentRgn,
ctypes.byref(rect))
width = rect.right - rect.left
height = rect.bottom - rect.top
if width != old_width or height != old_height:
window._resizing = width, height
window.switch_to()
window.dispatch_event('on_resize', width, height)
# Check for live dragging
if window._dragging:
allow_polling = False
# Check for deferred recreate
if window._recreate_deferred:
# Break out of ReceiveNextEvent so it can be processed
# in next iteration.
carbon.QuitEventLoop(self._event_loop)
self._force_idle = True
sleep_time = self.idle()
if sleep_time is None:
sleep_time = kEventDurationForever
elif sleep_time < 0.01 and allow_polling and self._allow_polling:
# Switch event loop to polling.
carbon.QuitEventLoop(self._event_loop)
self._force_idle = True
sleep_time = kEventDurationForever
carbon.SetEventLoopTimerNextFireTime(timer, ctypes.c_double(sleep_time))
'''
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Application-wide functionality.
Applications
------------
Most applications need only call :func:`run` after creating one or more
windows to begin processing events. For example, a simple application
consisting of one window is::
import pyglet
win = pyglet.window.Window()
pyglet.app.run()
Events
======
To handle events on the main event loop, instantiate it manually. The
following example exits the application as soon as any window is closed (the
default policy is to wait until all windows are closed)::
event_loop = pyglet.app.EventLoop()
@event_loop.event
def on_window_close(window):
event_loop.exit()
:since: pyglet 1.1
:attr:`event_loop` is the global event loop. Applications can replace this
with their own subclass of :class:`EventLoop` before calling
:meth:`EventLoop.run`.
:attr:`platform_event_loop` is the platform-dependent event loop.
Applications must not subclass or replace this :class:`PlatformEventLoop`
object.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import sys
import weakref
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
class AppException(Exception):
pass
class WeakSet(object):
'''Set of objects, referenced weakly.
Adding an object to this set does not prevent it from being garbage
collected. Upon being garbage collected, the object is automatically
removed from the set.
'''
def __init__(self):
self._dict = weakref.WeakKeyDictionary()
def add(self, value):
self._dict[value] = True
def remove(self, value):
del self._dict[value]
def __iter__(self):
for key in self._dict.keys():
yield key
def __contains__(self, other):
return other in self._dict
def __len__(self):
return len(self._dict)
displays = WeakSet()
'''Set of all open displays. Instances of :class:`pyglet.canvas.Display`
are automatically added to this set upon construction. The set uses weak
references, so displays are removed from the set when they are no longer
referenced.
:deprecated: Use :func:`pyglet.canvas.get_display`.
:type: :class:`WeakSet`
'''
windows = WeakSet()
'''Set of all open windows (including invisible windows). Instances of
:class:`pyglet.window.Window` are automatically added to this set upon
construction. The set uses weak references, so windows are removed from
the set when they are no longer referenced or are closed explicitly.
'''
def run():
'''Begin processing events, scheduled functions and window updates.
This is a convenience function, equivalent to::
pyglet.app.event_loop.run()
'''
event_loop.run()
def exit():
'''Exit the application event loop.
Causes the application event loop to finish, if an event loop is currently
running. The application may not necessarily exit (for example, there may
be additional code following the `run` invocation).
This is a convenience function, equivalent to::
event_loop.exit()
'''
event_loop.exit()
from pyglet.app.base import EventLoop
from pyglet import compat_platform
if _is_epydoc:
from pyglet.app.base import PlatformEventLoop
else:
if compat_platform == 'darwin':
from pyglet import options as pyglet_options
if pyglet_options['darwin_cocoa']:
from pyglet.app.cocoa import CocoaEventLoop as PlatformEventLoop
else:
from pyglet.app.carbon import CarbonEventLoop as PlatformEventLoop
elif compat_platform in ('win32', 'cygwin'):
from pyglet.app.win32 import Win32EventLoop as PlatformEventLoop
else:
from pyglet.app.xlib import XlibEventLoop as PlatformEventLoop
event_loop = EventLoop()
platform_event_loop = PlatformEventLoop()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
# TODO Tiger and later: need to set kWindowApplicationScaledAttribute for DPI
# independence?
import math
from pyglet.font import base
import pyglet.image
from pyglet.libs.darwin.cocoapy import *
class QuartzGlyphRenderer(base.GlyphRenderer):
def __init__(self, font):
super(QuartzGlyphRenderer, self).__init__(font)
self.font = font
def render(self, text):
# Using CTLineDraw seems to be the only way to make sure that the text
# is drawn with the specified font when that font is a graphics font loaded from
# memory. For whatever reason, [NSAttributedString drawAtPoint:] ignores
# the graphics font if it not registered with the font manager.
# So we just use CTLineDraw for both graphics fonts and installed fonts.
ctFont = self.font.ctFont
# Create an attributed string using text and font.
attributes = c_void_p(cf.CFDictionaryCreateMutable(None, 1, cf.kCFTypeDictionaryKeyCallBacks, cf.kCFTypeDictionaryValueCallBacks))
cf.CFDictionaryAddValue(attributes, kCTFontAttributeName, ctFont)
string = c_void_p(cf.CFAttributedStringCreate(None, CFSTR(text), attributes))
# Create a CTLine object to render the string.
line = c_void_p(ct.CTLineCreateWithAttributedString(string))
cf.CFRelease(string)
cf.CFRelease(attributes)
# Get a bounding rectangle for glyphs in string.
count = len(text)
chars = (UniChar * count)(*map(ord,unicode(text)))
glyphs = (CGGlyph * count)()
ct.CTFontGetGlyphsForCharacters(ctFont, chars, glyphs, count)
rect = ct.CTFontGetBoundingRectsForGlyphs(ctFont, 0, glyphs, None, count)
# Get advance for all glyphs in string.
advance = ct.CTFontGetAdvancesForGlyphs(ctFont, 0, glyphs, None, count)
# Set image parameters:
# We add 2 pixels to the bitmap width and height so that there will be a 1-pixel border
# around the glyph image when it is placed in the texture atlas. This prevents
# weird artifacts from showing up around the edges of the rendered glyph textures.
# We adjust the baseline and lsb of the glyph by 1 pixel accordingly.
width = max(int(math.ceil(rect.size.width) + 2), 1)
height = max(int(math.ceil(rect.size.height) + 2), 1)
baseline = -int(math.floor(rect.origin.y)) + 1
lsb = int(math.floor(rect.origin.x)) - 1
advance = int(round(advance))
# Create bitmap context.
bitsPerComponent = 8
bytesPerRow = 4*width
colorSpace = c_void_p(quartz.CGColorSpaceCreateDeviceRGB())
bitmap = c_void_p(quartz.CGBitmapContextCreate(
None,
width,
height,
bitsPerComponent,
bytesPerRow,
colorSpace,
kCGImageAlphaPremultipliedLast))
# Draw text to bitmap context.
quartz.CGContextSetShouldAntialias(bitmap, True)
quartz.CGContextSetTextPosition(bitmap, -lsb, baseline)
ct.CTLineDraw(line, bitmap)
cf.CFRelease(line)
# Create an image to get the data out.
imageRef = c_void_p(quartz.CGBitmapContextCreateImage(bitmap))
bytesPerRow = quartz.CGImageGetBytesPerRow(imageRef)
dataProvider = c_void_p(quartz.CGImageGetDataProvider(imageRef))
imageData = c_void_p(quartz.CGDataProviderCopyData(dataProvider))
buffersize = cf.CFDataGetLength(imageData)
buffer = (c_byte * buffersize)()
byteRange = CFRange(0, buffersize)
cf.CFDataGetBytes(imageData, byteRange, buffer)
quartz.CGImageRelease(imageRef)
quartz.CGDataProviderRelease(imageData)
cf.CFRelease(bitmap)
cf.CFRelease(colorSpace)
glyph_image = pyglet.image.ImageData(width, height, 'RGBA', buffer, bytesPerRow)
glyph = self.font.create_glyph(glyph_image)
glyph.set_bearings(baseline, lsb, advance)
t = list(glyph.tex_coords)
glyph.tex_coords = t[9:12] + t[6:9] + t[3:6] + t[:3]
return glyph
class QuartzFont(base.Font):
glyph_renderer_class = QuartzGlyphRenderer
_loaded_CGFont_table = {}
def _lookup_font_with_family_and_traits(self, family, traits):
# This method searches the _loaded_CGFont_table to find a loaded
# font of the given family with the desired traits. If it can't find
# anything with the exact traits, it tries to fall back to whatever
# we have loaded that's close. If it can't find anything in the
# given family at all, it returns None.
# Check if we've loaded the font with the specified family.
if family not in self._loaded_CGFont_table:
return None
# Grab a dictionary of all fonts in the family, keyed by traits.
fonts = self._loaded_CGFont_table[family]
if not fonts:
return None
# Return font with desired traits if it is available.
if traits in fonts:
return fonts[traits]
# Otherwise try to find a font with some of the traits.
for (t, f) in fonts.items():
if traits & t:
return f
# Otherwise try to return a regular font.
if 0 in fonts:
return fonts[0]
# Otherwise return whatever we have.
return fonts.values()[0]
def _create_font_descriptor(self, family_name, traits):
# Create an attribute dictionary.
attributes = c_void_p(cf.CFDictionaryCreateMutable(None, 0, cf.kCFTypeDictionaryKeyCallBacks, cf.kCFTypeDictionaryValueCallBacks))
# Add family name to attributes.
cfname = CFSTR(family_name)
cf.CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, cfname)
cf.CFRelease(cfname)
# Construct a CFNumber to represent the traits.
itraits = c_int32(traits)
symTraits = c_void_p(cf.CFNumberCreate(None, kCFNumberSInt32Type, byref(itraits)))
if symTraits:
# Construct a dictionary to hold the traits values.
traitsDict = c_void_p(cf.CFDictionaryCreateMutable(None, 0, cf.kCFTypeDictionaryKeyCallBacks, cf.kCFTypeDictionaryValueCallBacks))
if traitsDict:
# Add CFNumber traits to traits dictionary.
cf.CFDictionaryAddValue(traitsDict, kCTFontSymbolicTrait, symTraits)
# Add traits dictionary to attributes.
cf.CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traitsDict)
cf.CFRelease(traitsDict)
cf.CFRelease(symTraits)
# Create font descriptor with attributes.
descriptor = c_void_p(ct.CTFontDescriptorCreateWithAttributes(attributes))
cf.CFRelease(attributes)
return descriptor
def __init__(self, name, size, bold=False, italic=False, dpi=None):
super(QuartzFont, self).__init__()
if not name: name = 'Helvetica'
# I don't know what is the right thing to do here.
if dpi is None: dpi = 96
size = size * dpi / 72.0
# Construct traits value.
traits = 0
if bold: traits |= kCTFontBoldTrait
if italic: traits |= kCTFontItalicTrait
name = unicode(name)
# First see if we can find an appropriate font from our table of loaded fonts.
cgFont = self._lookup_font_with_family_and_traits(name, traits)
if cgFont:
# Use cgFont from table to create a CTFont object with the specified size.
self.ctFont = c_void_p(ct.CTFontCreateWithGraphicsFont(cgFont, size, None, None))
else:
# Create a font descriptor for given name and traits and use it to create font.
descriptor = self._create_font_descriptor(name, traits)
self.ctFont = c_void_p(ct.CTFontCreateWithFontDescriptor(descriptor, size, None))
assert self.ctFont, "Couldn't load font: " + name
self.ascent = int(math.ceil(ct.CTFontGetAscent(self.ctFont)))
self.descent = -int(math.ceil(ct.CTFontGetDescent(self.ctFont)))
@classmethod
def have_font(cls, name):
name = unicode(name)
if name in cls._loaded_CGFont_table: return True
# Try to create the font to see if it exists.
# TODO: Find a better way to check.
cfstring = CFSTR(name)
cgfont = c_void_p(quartz.CGFontCreateWithFontName(cfstring))
cf.CFRelease(cfstring)
if cgfont:
cf.CFRelease(cgfont)
return True
return False
@classmethod
def add_font_data(cls, data):
# Create a cgFont with the data. There doesn't seem to be a way to
# register a font loaded from memory such that the operating system will
# find it later. So instead we just store the cgFont in a table where
# it can be found by our __init__ method.
# Note that the iOS CTFontManager *is* able to register graphics fonts,
# however this method is missing from CTFontManager on MacOS 10.6
dataRef = c_void_p(cf.CFDataCreate(None, data, len(data)))
provider = c_void_p(quartz.CGDataProviderCreateWithCFData(dataRef))
cgFont = c_void_p(quartz.CGFontCreateWithDataProvider(provider))
cf.CFRelease(dataRef)
quartz.CGDataProviderRelease(provider)
# Create a template CTFont from the graphics font so that we can get font info.
ctFont = c_void_p(ct.CTFontCreateWithGraphicsFont(cgFont, 1, None, None))
# Get info about the font to use as key in our font table.
string = c_void_p(ct.CTFontCopyFamilyName(ctFont))
familyName = unicode(cfstring_to_string(string))
cf.CFRelease(string)
string = c_void_p(ct.CTFontCopyFullName(ctFont))
fullName = unicode(cfstring_to_string(string))
cf.CFRelease(string)
traits = ct.CTFontGetSymbolicTraits(ctFont)
cf.CFRelease(ctFont)
# Store font in table. We store it under both its family name and its
# full name, since its not always clear which one will be looked up.
if familyName not in cls._loaded_CGFont_table:
cls._loaded_CGFont_table[familyName] = {}
cls._loaded_CGFont_table[familyName][traits] = cgFont
if fullName not in cls._loaded_CGFont_table:
cls._loaded_CGFont_table[fullName] = {}
cls._loaded_CGFont_table[fullName][traits] = cgFont
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from base import FontException
import pyglet.lib
_libfreetype = pyglet.lib.load_library('freetype')
_font_data = {}
def _get_function(name, argtypes, rtype):
try:
func = getattr(_libfreetype, name)
func.argtypes = argtypes
func.restype = rtype
return func
except AttributeError, e:
raise ImportError(e)
FT_Done_FreeType = _get_function('FT_Done_FreeType', [c_void_p], None)
FT_Done_Face = _get_function('FT_Done_Face', [c_void_p], None)
class FT_LibraryRec(Structure):
_fields_ = [
('dummy', c_int),
]
def __del__(self):
global _library
try:
FT_Done_FreeType(byref(self))
_library = None
except:
pass
FT_Library = POINTER(FT_LibraryRec)
class FT_Glyph_Metrics(Structure):
_fields_ = [
('width', c_long),
('height', c_long),
('horiBearingX', c_long),
('horiBearingY', c_long),
('horiAdvance', c_long),
('vertBearingX', c_long),
('vertBearingY', c_long),
('vertAdvance', c_long),
]
def dump(self):
for (name, type) in self._fields_:
print 'FT_Glyph_Metrics', name, `getattr(self, name)`
class FT_Generic(Structure):
_fields_ = [('data', c_void_p), ('finalizer', c_void_p)]
class FT_BBox(Structure):
_fields_ = [('xMin', c_long), ('yMin', c_long), ('xMax', c_long),
('yMax', c_long)]
class FT_Vector(Structure):
_fields_ = [('x', c_long), ('y', c_long)]
class FT_Bitmap(Structure):
_fields_ = [
('rows', c_int),
('width', c_int),
('pitch', c_int),
# declaring buffer as c_char_p confuses ctypes, poor dear
('buffer', POINTER(c_ubyte)),
('num_grays', c_short),
('pixel_mode', c_ubyte),
('palette_mode', c_char),
('palette', c_void_p),
]
class FT_Outline(Structure):
_fields_ = [
('n_contours', c_short), # number of contours in glyph
('n_points', c_short), # number of points in the glyph
('points', POINTER(FT_Vector)), # the outline's points
('tags', c_char_p), # the points flags
('contours', POINTER(c_short)), # the contour end points
('flags', c_int), # outline masks
]
class FT_GlyphSlotRec(Structure):
_fields_ = [
('library', FT_Library),
('face', c_void_p),
('next', c_void_p),
('reserved', c_uint),
('generic', FT_Generic),
('metrics', FT_Glyph_Metrics),
('linearHoriAdvance', c_long),
('linearVertAdvance', c_long),
('advance', FT_Vector),
('format', c_int),
('bitmap', FT_Bitmap),
('bitmap_left', c_int),
('bitmap_top', c_int),
('outline', FT_Outline),
('num_subglyphs', c_uint),
('subglyphs', c_void_p),
('control_data', c_void_p),
('control_len', c_long),
('lsb_delta', c_long),
('rsb_delta', c_long),
('other', c_void_p),
('internal', c_void_p),
]
FT_GlyphSlot = POINTER(FT_GlyphSlotRec)
class FT_Size_Metrics(Structure):
_fields_ = [
('x_ppem', c_ushort), # horizontal pixels per EM
('y_ppem', c_ushort), # vertical pixels per EM
('x_scale', c_long), # two scales used to convert font units
('y_scale', c_long), # to 26.6 frac. pixel coordinates
('ascender', c_long), # ascender in 26.6 frac. pixels
('descender', c_long), # descender in 26.6 frac. pixels
('height', c_long), # text height in 26.6 frac. pixels
('max_advance', c_long), # max horizontal advance, in 26.6 pixels
]
class FT_SizeRec(Structure):
_fields_ = [
('face', c_void_p),
('generic', FT_Generic),
('metrics', FT_Size_Metrics),
('internal', c_void_p),
]
FT_Size = POINTER(FT_SizeRec)
class FT_Bitmap_Size(Structure):
_fields_ = [
('height', c_ushort),
('width', c_ushort),
('size', c_long),
('x_ppem', c_long),
('y_ppem', c_long),
]
# face_flags values
FT_FACE_FLAG_SCALABLE = 1 << 0
FT_FACE_FLAG_FIXED_SIZES = 1 << 1
FT_FACE_FLAG_FIXED_WIDTH = 1 << 2
FT_FACE_FLAG_SFNT = 1 << 3
FT_FACE_FLAG_HORIZONTAL = 1 << 4
FT_FACE_FLAG_VERTICAL = 1 << 5
FT_FACE_FLAG_KERNING = 1 << 6
FT_FACE_FLAG_FAST_GLYPHS = 1 << 7
FT_FACE_FLAG_MULTIPLE_MASTERS = 1 << 8
FT_FACE_FLAG_GLYPH_NAMES = 1 << 9
FT_FACE_FLAG_EXTERNAL_STREAM = 1 << 10
FT_FACE_FLAG_HINTER = 1 << 11
class FT_FaceRec(Structure):
_fields_ = [
('num_faces', c_long),
('face_index', c_long),
('face_flags', c_long),
('style_flags', c_long),
('num_glyphs', c_long),
('family_name', c_char_p),
('style_name', c_char_p),
('num_fixed_sizes', c_int),
('available_sizes', POINTER(FT_Bitmap_Size)),
('num_charmaps', c_int),
('charmaps', c_void_p),
('generic', FT_Generic),
('bbox', FT_BBox),
('units_per_EM', c_ushort),
('ascender', c_short),
('descender', c_short),
('height', c_short),
('max_advance_width', c_short),
('max_advance_height', c_short),
('underline_position', c_short),
('underline_thickness', c_short),
('glyph', FT_GlyphSlot),
('size', FT_Size),
('charmap', c_void_p),
('driver', c_void_p),
('memory', c_void_p),
('stream', c_void_p),
('sizes_list_head', c_void_p),
('sizes_list_tail', c_void_p),
('autohint', FT_Generic),
('extensions', c_void_p),
('internal', c_void_p),
]
def dump(self):
for (name, type) in self._fields_:
print 'FT_FaceRec', name, `getattr(self, name)`
def has_kerning(self):
return self.face_flags & FT_FACE_FLAG_KERNING
FT_Face = POINTER(FT_FaceRec)
class Error(Exception):
def __init__(self, message, errcode):
self.message = message
self.errcode = errcode
def __str__(self):
return '%s: %s (%s)'%(self.__class__.__name__, self.message,
self._ft_errors.get(self.errcode, 'unknown error'))
_ft_errors = {
0x00: "no error" ,
0x01: "cannot open resource" ,
0x02: "unknown file format" ,
0x03: "broken file" ,
0x04: "invalid FreeType version" ,
0x05: "module version is too low" ,
0x06: "invalid argument" ,
0x07: "unimplemented feature" ,
0x08: "broken table" ,
0x09: "broken offset within table" ,
0x10: "invalid glyph index" ,
0x11: "invalid character code" ,
0x12: "unsupported glyph image format" ,
0x13: "cannot render this glyph format" ,
0x14: "invalid outline" ,
0x15: "invalid composite glyph" ,
0x16: "too many hints" ,
0x17: "invalid pixel size" ,
0x20: "invalid object handle" ,
0x21: "invalid library handle" ,
0x22: "invalid module handle" ,
0x23: "invalid face handle" ,
0x24: "invalid size handle" ,
0x25: "invalid glyph slot handle" ,
0x26: "invalid charmap handle" ,
0x27: "invalid cache manager handle" ,
0x28: "invalid stream handle" ,
0x30: "too many modules" ,
0x31: "too many extensions" ,
0x40: "out of memory" ,
0x41: "unlisted object" ,
0x51: "cannot open stream" ,
0x52: "invalid stream seek" ,
0x53: "invalid stream skip" ,
0x54: "invalid stream read" ,
0x55: "invalid stream operation" ,
0x56: "invalid frame operation" ,
0x57: "nested frame access" ,
0x58: "invalid frame read" ,
0x60: "raster uninitialized" ,
0x61: "raster corrupted" ,
0x62: "raster overflow" ,
0x63: "negative height while rastering" ,
0x70: "too many registered caches" ,
0x80: "invalid opcode" ,
0x81: "too few arguments" ,
0x82: "stack overflow" ,
0x83: "code overflow" ,
0x84: "bad argument" ,
0x85: "division by zero" ,
0x86: "invalid reference" ,
0x87: "found debug opcode" ,
0x88: "found ENDF opcode in execution stream" ,
0x89: "nested DEFS" ,
0x8A: "invalid code range" ,
0x8B: "execution context too long" ,
0x8C: "too many function definitions" ,
0x8D: "too many instruction definitions" ,
0x8E: "SFNT font table missing" ,
0x8F: "horizontal header (hhea, table missing" ,
0x90: "locations (loca, table missing" ,
0x91: "name table missing" ,
0x92: "character map (cmap, table missing" ,
0x93: "horizontal metrics (hmtx, table missing" ,
0x94: "PostScript (post, table missing" ,
0x95: "invalid horizontal metrics" ,
0x96: "invalid character map (cmap, format" ,
0x97: "invalid ppem value" ,
0x98: "invalid vertical metrics" ,
0x99: "could not find context" ,
0x9A: "invalid PostScript (post, table format" ,
0x9B: "invalid PostScript (post, table" ,
0xA0: "opcode syntax error" ,
0xA1: "argument stack underflow" ,
0xA2: "ignore" ,
0xB0: "`STARTFONT' field missing" ,
0xB1: "`FONT' field missing" ,
0xB2: "`SIZE' field missing" ,
0xB3: "`CHARS' field missing" ,
0xB4: "`STARTCHAR' field missing" ,
0xB5: "`ENCODING' field missing" ,
0xB6: "`BBX' field missing" ,
0xB7: "`BBX' too big" ,
}
FT_LOAD_RENDER = 0x4
FT_F26Dot6 = c_long
FT_Init_FreeType = _get_function('FT_Init_FreeType',
[POINTER(FT_Library)], c_int)
FT_New_Memory_Face = _get_function('FT_New_Memory_Face',
[FT_Library, POINTER(c_byte), c_long, c_long, POINTER(FT_Face)], c_int)
FT_New_Face = _get_function('FT_New_Face',
[FT_Library, c_char_p, c_long, POINTER(FT_Face)], c_int)
FT_Set_Pixel_Sizes = _get_function('FT_Set_Pixel_Sizes',
[FT_Face, c_uint, c_uint], c_int)
FT_Set_Char_Size = _get_function('FT_Set_Char_Size',
[FT_Face, FT_F26Dot6, FT_F26Dot6, c_uint, c_uint], c_int)
FT_Load_Glyph = _get_function('FT_Load_Glyph',
[FT_Face, c_uint, c_int32], c_int)
FT_Get_Char_Index = _get_function('FT_Get_Char_Index',
[FT_Face, c_ulong], c_uint)
FT_Load_Char = _get_function('FT_Load_Char',
[FT_Face, c_ulong, c_int], c_int)
FT_Get_Kerning = _get_function('FT_Get_Kerning',
[FT_Face, c_uint, c_uint, c_uint, POINTER(FT_Vector)], c_int)
# SFNT interface
class FT_SfntName(Structure):
_fields_ = [
('platform_id', c_ushort),
('encoding_id', c_ushort),
('language_id', c_ushort),
('name_id', c_ushort),
('string', POINTER(c_byte)),
('string_len', c_uint)
]
FT_Get_Sfnt_Name_Count = _get_function('FT_Get_Sfnt_Name_Count',
[FT_Face], c_uint)
FT_Get_Sfnt_Name = _get_function('FT_Get_Sfnt_Name',
[FT_Face, c_uint, POINTER(FT_SfntName)], c_int)
TT_PLATFORM_MICROSOFT = 3
TT_MS_ID_UNICODE_CS = 1
TT_NAME_ID_COPYRIGHT = 0
TT_NAME_ID_FONT_FAMILY = 1
TT_NAME_ID_FONT_SUBFAMILY = 2
TT_NAME_ID_UNIQUE_ID = 3
TT_NAME_ID_FULL_NAME = 4
TT_NAME_ID_VERSION_STRING = 5
TT_NAME_ID_PS_NAME = 6
TT_NAME_ID_TRADEMARK = 7
TT_NAME_ID_MANUFACTURER = 8
TT_NAME_ID_DESIGNER = 9
TT_NAME_ID_DESCRIPTION = 10
TT_NAME_ID_VENDOR_URL = 11
TT_NAME_ID_DESIGNER_URL = 12
TT_NAME_ID_LICENSE = 13
TT_NAME_ID_LICENSE_URL = 14
TT_NAME_ID_PREFERRED_FAMILY = 16
TT_NAME_ID_PREFERRED_SUBFAMILY= 17
TT_NAME_ID_MAC_FULL_NAME = 18
TT_NAME_ID_CID_FINDFONT_NAME = 20
_library = None
def ft_get_library():
global _library
if not _library:
_library = FT_Library()
error = FT_Init_FreeType(byref(_library))
if error:
raise FontException(
'an error occurred during library initialization', error)
return _library
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Abstract classes used by pyglet.font implementations.
These classes should not be constructed directly. Instead, use the functions
in `pyglet.font` to obtain platform-specific instances. You can use these
classes as a documented interface to the concrete classes.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import unicodedata
from pyglet.gl import *
from pyglet import image
_other_grapheme_extend = \
map(unichr, [0x09be, 0x09d7, 0x0be3, 0x0b57, 0x0bbe, 0x0bd7, 0x0cc2,
0x0cd5, 0x0cd6, 0x0d3e, 0x0d57, 0x0dcf, 0x0ddf, 0x200c,
0x200d, 0xff9e, 0xff9f]) # skip codepoints above U+10000
_logical_order_exception = \
map(unichr, range(0xe40, 0xe45) + range(0xec0, 0xec4))
_grapheme_extend = lambda c, cc: \
cc in ('Me', 'Mn') or c in _other_grapheme_extend
_CR = u'\u000d'
_LF = u'\u000a'
_control = lambda c, cc: cc in ('ZI', 'Zp', 'Cc', 'Cf') and not \
c in map(unichr, [0x000d, 0x000a, 0x200c, 0x200d])
_extend = lambda c, cc: _grapheme_extend(c, cc) or \
c in map(unichr, [0xe30, 0xe32, 0xe33, 0xe45, 0xeb0, 0xeb2, 0xeb3])
_prepend = lambda c, cc: c in _logical_order_exception
_spacing_mark = lambda c, cc: cc == 'Mc' and c not in _other_grapheme_extend
def _grapheme_break(left, right):
# GB1
if left is None:
return True
# GB2 not required, see end of get_grapheme_clusters
# GB3
if left == _CR and right == _LF:
return False
left_cc = unicodedata.category(left)
# GB4
if _control(left, left_cc):
return True
right_cc = unicodedata.category(right)
# GB5
if _control(right, right_cc):
return True
# GB6, GB7, GB8 not implemented
# GB9
if _extend(right, right_cc):
return False
# GB9a
if _spacing_mark(right, right_cc):
return False
# GB9b
if _prepend(left, left_cc):
return False
# GB10
return True
def get_grapheme_clusters(text):
'''Implements Table 2 of UAX #29: Grapheme Cluster Boundaries.
Does not currently implement Hangul syllable rules.
:Parameters:
`text` : unicode
String to cluster.
:since: pyglet 1.1.2
:rtype: List of `unicode`
:return: List of Unicode grapheme clusters
'''
clusters = []
cluster = ''
left = None
for right in text:
if cluster and _grapheme_break(left, right):
clusters.append(cluster)
cluster = ''
elif cluster:
# Add a zero-width space to keep len(clusters) == len(text)
clusters.append(u'\u200b')
cluster += right
left = right
# GB2
if cluster:
clusters.append(cluster)
return clusters
class Glyph(image.TextureRegion):
'''A single glyph located within a larger texture.
Glyphs are drawn most efficiently using the higher level APIs, for example
`GlyphString`.
:Ivariables:
`advance` : int
The horizontal advance of this glyph, in pixels.
`vertices` : (int, int, int, int)
The vertices of this glyph, with (0,0) originating at the
left-side bearing at the baseline.
'''
advance = 0
vertices = (0, 0, 0, 0)
def set_bearings(self, baseline, left_side_bearing, advance):
'''Set metrics for this glyph.
:Parameters:
`baseline` : int
Distance from the bottom of the glyph to its baseline;
typically negative.
`left_side_bearing` : int
Distance to add to the left edge of the glyph.
`advance` : int
Distance to move the horizontal advance to the next glyph.
'''
self.advance = advance
self.vertices = (
left_side_bearing,
-baseline,
left_side_bearing + self.width,
-baseline + self.height)
def draw(self):
'''Debug method.
Use the higher level APIs for performance and kerning.
'''
glBindTexture(GL_TEXTURE_2D, self.owner.id)
glBegin(GL_QUADS)
self.draw_quad_vertices()
glEnd()
def draw_quad_vertices(self):
'''Debug method.
Use the higher level APIs for performance and kerning.
'''
glTexCoord3f(*self.tex_coords[:3])
glVertex2f(self.vertices[0], self.vertices[1])
glTexCoord3f(*self.tex_coords[3:6])
glVertex2f(self.vertices[2], self.vertices[1])
glTexCoord3f(*self.tex_coords[6:9])
glVertex2f(self.vertices[2], self.vertices[3])
glTexCoord3f(*self.tex_coords[9:12])
glVertex2f(self.vertices[0], self.vertices[3])
def get_kerning_pair(self, right_glyph):
'''Not implemented.
'''
return 0
class GlyphTextureAtlas(image.Texture):
'''A texture within which glyphs can be drawn.
'''
region_class = Glyph
x = 0
y = 0
line_height = 0
def apply_blend_state(self):
'''Set the OpenGL blend state for the glyphs in this texture.
'''
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_BLEND)
def fit(self, image):
'''Place `image` within this texture.
:Parameters:
`image` : `pyglet.image.AbstractImage`
Image to place within the texture.
:rtype: `Glyph`
:return: The glyph representing the image from this texture, or None
if the image doesn't fit.
'''
if self.x + image.width > self.width:
self.x = 0
self.y += self.line_height + 1
self.line_height = 0
if self.y + image.height > self.height:
return None
self.line_height = max(self.line_height, image.height)
region = self.get_region(
self.x, self.y, image.width, image.height)
if image.width > 0:
region.blit_into(image, 0, 0, 0)
self.x += image.width + 1
return region
class GlyphRenderer(object):
'''Abstract class for creating glyph images.
'''
def __init__(self, font):
pass
def render(self, text):
raise NotImplementedError('Subclass must override')
class FontException(Exception):
'''Generic exception related to errors from the font module. Typically
these relate to invalid font data.'''
pass
class Font(object):
'''Abstract font class able to produce glyphs.
To construct a font, use `pyglet.font.load`, which will instantiate the
platform-specific font class.
Internally, this class is used by the platform classes to manage the set
of textures into which glyphs are written.
:Ivariables:
`ascent` : int
Maximum ascent above the baseline, in pixels.
`descent` : int
Maximum descent below the baseline, in pixels. Usually negative.
'''
texture_width = 256
texture_height = 256
texture_internalformat = GL_ALPHA
# These should also be set by subclass when known
ascent = 0
descent = 0
glyph_renderer_class = GlyphRenderer
texture_class = GlyphTextureAtlas
def __init__(self):
self.textures = []
self.glyphs = {}
@classmethod
def add_font_data(cls, data):
'''Add font data to the font loader.
This is a class method and affects all fonts loaded. Data must be
some byte string of data, for example, the contents of a TrueType font
file. Subclasses can override this method to add the font data into
the font registry.
There is no way to instantiate a font given the data directly, you
must use `pyglet.font.load` specifying the font name.
'''
pass
@classmethod
def have_font(cls, name):
'''Determine if a font with the given name is installed.
:Parameters:
`name` : str
Name of a font to search for
:rtype: bool
'''
return True
def create_glyph(self, image):
'''Create a glyph using the given image.
This is used internally by `Font` subclasses to add glyph data
to the font. Glyphs are packed within large textures maintained by
`Font`. This method inserts the image into a font texture and returns
a glyph reference; it is up to the subclass to add metadata to the
glyph.
Applications should not use this method directly.
:Parameters:
`image` : `pyglet.image.AbstractImage`
The image to write to the font texture.
:rtype: `Glyph`
'''
glyph = None
for texture in self.textures:
glyph = texture.fit(image)
if glyph:
break
if not glyph:
if image.width > self.texture_width or \
image.height > self.texture_height:
texture = self.texture_class.create_for_size(GL_TEXTURE_2D,
image.width * 2, image.height * 2,
self.texture_internalformat)
self.texture_width = texture.width
self.texture_height = texture.height
else:
texture = self.texture_class.create_for_size(GL_TEXTURE_2D,
self.texture_width, self.texture_height,
self.texture_internalformat)
self.textures.insert(0, texture)
glyph = texture.fit(image)
return glyph
def get_glyphs(self, text):
'''Create and return a list of Glyphs for `text`.
If any characters do not have a known glyph representation in this
font, a substitution will be made.
:Parameters:
`text` : str or unicode
Text to render.
:rtype: list of `Glyph`
'''
glyph_renderer = None
glyphs = [] # glyphs that are committed.
for c in get_grapheme_clusters(unicode(text)):
# Get the glyph for 'c'. Hide tabs (Windows and Linux render
# boxes)
if c == '\t':
c = ' '
if c not in self.glyphs:
if not glyph_renderer:
glyph_renderer = self.glyph_renderer_class(self)
self.glyphs[c] = glyph_renderer.render(c)
glyphs.append(self.glyphs[c])
return glyphs
def get_glyphs_for_width(self, text, width):
'''Return a list of glyphs for `text` that fit within the given width.
If the entire text is larger than 'width', as much as possible will be
used while breaking after a space or zero-width space character. If a
newline is encountered in text, only text up to that newline will be
used. If no break opportunities (newlines or spaces) occur within
`width`, the text up to the first break opportunity will be used (this
will exceed `width`). If there are no break opportunities, the entire
text will be used.
You can assume that each character of the text is represented by
exactly one glyph; so the amount of text "used up" can be determined
by examining the length of the returned glyph list.
:Parameters:
`text` : str or unicode
Text to render.
`width` : int
Maximum width of returned glyphs.
:rtype: list of `Glyph`
:see: `GlyphString`
'''
glyph_renderer = None
glyph_buffer = [] # next glyphs to be added, as soon as a BP is found
glyphs = [] # glyphs that are committed.
for c in text:
if c == '\n':
glyphs += glyph_buffer
break
# Get the glyph for 'c'
if c not in self.glyphs:
if not glyph_renderer:
glyph_renderer = self.glyph_renderer_class(self)
self.glyphs[c] = glyph_renderer.render(c)
glyph = self.glyphs[c]
# Add to holding buffer and measure
glyph_buffer.append(glyph)
width -= glyph.advance
# If over width and have some committed glyphs, finish.
if width <= 0 and len(glyphs) > 0:
break
# If a valid breakpoint, commit holding buffer
if c in u'\u0020\u200b':
glyphs += glyph_buffer
glyph_buffer = []
# If nothing was committed, commit everything (no breakpoints found).
if len(glyphs) == 0:
glyphs = glyph_buffer
return glyphs
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id$
"""
Implementation of the Truetype file format.
Typical applications will not need to use this module directly; look at
`pyglyph.font` instead.
References:
* http://developer.apple.com/fonts/TTRefMan/RM06
* http://www.microsoft.com/typography/otspec
"""
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import codecs
import os
import mmap
import struct
class TruetypeInfo:
"""Information about a single Truetype face.
The class memory-maps the font file to read the tables, so
it is vital that you call the `close` method to avoid large memory
leaks. Once closed, you cannot call any of the ``get_*`` methods.
Not all tables have been implemented yet (or likely ever will).
Currently only the name and metric tables are read; in particular
there is no glyph or hinting information.
"""
_name_id_lookup = {
'copyright': 0,
'family': 1,
'subfamily': 2,
'identifier': 3,
'name': 4,
'version': 5,
'postscript': 6,
'trademark': 7,
'manufacturer': 8,
'designer': 9,
'description': 10,
'vendor-url': 11,
'designer-url': 12,
'license': 13,
'license-url': 14,
'preferred-family': 16,
'preferred-subfamily': 17,
'compatible-name': 18,
'sample': 19,
}
_platform_id_lookup = {
'unicode': 0,
'macintosh': 1,
'iso': 2,
'microsoft': 3,
'custom': 4
}
_microsoft_encoding_lookup = {
1: 'utf_16_be',
2: 'shift_jis',
4: 'big5',
6: 'johab',
10: 'utf_16_be'
}
_macintosh_encoding_lookup = {
0: 'mac_roman'
}
def __init__(self, filename):
"""Read the given TrueType file.
:Parameters:
`filename`
The name of any Windows, OS2 or Macintosh Truetype file.
The object must be closed (see `close`) after use.
An exception will be raised if the file does not exist or cannot
be read.
"""
if not filename: filename = ''
len = os.stat(filename).st_size
self._fileno = os.open(filename, os.O_RDONLY)
if hasattr(mmap, 'MAP_SHARED'):
self._data = mmap.mmap(self._fileno, len, mmap.MAP_SHARED,
mmap.PROT_READ)
else:
self._data = mmap.mmap(self._fileno, len, None, mmap.ACCESS_READ)
offsets = _read_offset_table(self._data, 0)
self._tables = {}
for table in _read_table_directory_entry.array(self._data,
offsets.size, offsets.num_tables):
self._tables[table.tag] = table
self._names = None
self._horizontal_metrics = None
self._character_advances = None
self._character_kernings = None
self._glyph_kernings = None
self._character_map = None
self._glyph_map = None
self._font_selection_flags = None
self.header = \
_read_head_table(self._data, self._tables['head'].offset)
self.horizontal_header = \
_read_horizontal_header(self._data, self._tables['hhea'].offset)
def get_font_selection_flags(self):
"""Return the font selection flags, as defined in OS/2 table"""
if not self._font_selection_flags:
OS2_table = \
_read_OS2_table(self._data, self._tables['OS/2'].offset)
self._font_selection_flags = OS2_table.fs_selection
return self._font_selection_flags
def is_bold(self):
"""Returns True iff the font describes itself as bold."""
return bool(self.get_font_selection_flags() & 0x20)
def is_italic(self):
"""Returns True iff the font describes itself as italic."""
return bool(self.get_font_selection_flags() & 0x1)
def get_names(self):
"""Returns a dictionary of names defined in the file.
The key of each item is a tuple of ``platform_id``, ``name_id``,
where each ID is the number as described in the Truetype format.
The value of each item is a tuple of
``encoding_id``, ``language_id``, ``value``, where ``value`` is
an encoded string.
"""
if self._names:
return self._names
naming_table = \
_read_naming_table(self._data, self._tables['name'].offset)
name_records = \
_read_name_record.array(self._data,
self._tables['name'].offset + naming_table.size,
naming_table.count)
storage = naming_table.string_offset + self._tables['name'].offset
self._names = {}
for record in name_records:
value = self._data[record.offset + storage:\
record.offset + storage + record.length]
key = record.platform_id, record.name_id
value = (record.encoding_id, record.language_id, value)
if not key in self._names:
self._names[key] = []
self._names[key].append(value)
return self._names
def get_name(self, name, platform=None, languages=None):
"""Returns the value of the given name in this font.
:Parameters:
`name`
Either an integer, representing the name_id desired (see
font format); or a string describing it, see below for
valid names.
`platform`
Platform for the requested name. Can be the integer ID,
or a string describing it. By default, the Microsoft
platform is searched first, then Macintosh.
`languages`
A list of language IDs to search. The first language
which defines the requested name will be used. By default,
all English dialects are searched.
If the name is not found, ``None`` is returned. If the name
is found, the value will be decoded and returned as a unicode
string. Currently only some common encodings are supported.
Valid names to request are (supply as a string)::
'copyright'
'family'
'subfamily'
'identifier'
'name'
'version'
'postscript'
'trademark'
'manufacturer'
'designer'
'description'
'vendor-url'
'designer-url'
'license'
'license-url'
'preferred-family'
'preferred-subfamily'
'compatible-name'
'sample'
Valid platforms to request are (supply as a string)::
'unicode'
'macintosh'
'iso'
'microsoft'
'custom'
"""
names = self.get_names()
if type(name) == str:
name = self._name_id_lookup[name]
if not platform:
for platform in ('microsoft','macintosh'):
value = self.get_name(name, platform, languages)
if value:
return value
if type(platform) == str:
platform = self._platform_id_lookup[platform]
if not (platform, name) in names:
return None
if platform == 3: # setup for microsoft
encodings = self._microsoft_encoding_lookup
if not languages:
# Default to english languages for microsoft
languages = (0x409,0x809,0xc09,0x1009,0x1409,0x1809)
elif platform == 1: # setup for macintosh
encodings = self.__macintosh_encoding_lookup
if not languages:
# Default to english for macintosh
languages = (0,)
for record in names[(platform, name)]:
if record[1] in languages and record[0] in encodings:
decoder = codecs.getdecoder(encodings[record[0]])
return decoder(record[2])[0]
return None
def get_horizontal_metrics(self):
"""Return all horizontal metric entries in table format."""
if not self._horizontal_metrics:
ar = _read_long_hor_metric.array(self._data,
self._tables['hmtx'].offset,
self.horizontal_header.number_of_h_metrics)
self._horizontal_metrics = ar
return self._horizontal_metrics
def get_character_advances(self):
"""Return a dictionary of character->advance.
They key of the dictionary is a unit-length unicode string,
and the value is a float giving the horizontal advance in
em.
"""
if self._character_advances:
return self._character_advances
ga = self.get_glyph_advances()
gmap = self.get_glyph_map()
self._character_advances = {}
for i in range(len(ga)):
if i in gmap and not gmap[i] in self._character_advances:
self._character_advances[gmap[i]] = ga[i]
return self._character_advances
def get_glyph_advances(self):
"""Return a dictionary of glyph->advance.
They key of the dictionary is the glyph index and the value is a float
giving the horizontal advance in em.
"""
hm = self.get_horizontal_metrics()
return [float(m.advance_width) / self.header.units_per_em for m in hm]
def get_character_kernings(self):
"""Return a dictionary of (left,right)->kerning
The key of the dictionary is a tuple of ``(left, right)``
where each element is a unit-length unicode string. The
value of the dictionary is the horizontal pairwise kerning
in em.
"""
if not self._character_kernings:
gmap = self.get_glyph_map()
kerns = self.get_glyph_kernings()
self._character_kernings = {}
for pair, value in kerns.items():
lglyph, rglyph = pair
lchar = lglyph in gmap and gmap[lglyph] or None
rchar = rglyph in gmap and gmap[rglyph] or None
if lchar and rchar:
self._character_kernings[(lchar, rchar)] = value
return self._character_kernings
def get_glyph_kernings(self):
"""Return a dictionary of (left,right)->kerning
The key of the dictionary is a tuple of ``(left, right)``
where each element is a glyph index. The value of the dictionary is
the horizontal pairwise kerning in em.
"""
if self._glyph_kernings:
return self._glyph_kernings
header = \
_read_kern_header_table(self._data, self._tables['kern'].offset)
offset = self._tables['kern'].offset + header.size
kernings = {}
for i in range(header.n_tables):
header = _read_kern_subtable_header(self._data, offset)
if header.coverage & header.horizontal_mask \
and not header.coverage & header.minimum_mask \
and not header.coverage & header.perpendicular_mask:
if header.coverage & header.format_mask == 0:
self._add_kernings_format0(kernings, offset + header.size)
offset += header.length
self._glyph_kernings = kernings
return kernings
def _add_kernings_format0(self, kernings, offset):
header = _read_kern_subtable_format0(self._data, offset)
kerning_pairs = _read_kern_subtable_format0Pair.array(self._data,
offset + header.size, header.n_pairs)
for pair in kerning_pairs:
if (pair.left, pair.right) in kernings:
kernings[(pair.left, pair.right)] += pair.value \
/ float(self.header.units_per_em)
else:
kernings[(pair.left, pair.right)] = pair.value \
/ float(self.header.units_per_em)
def get_glyph_map(self):
"""Calculate and return a reverse character map.
Returns a dictionary where the key is a glyph index and the
value is a unit-length unicode string.
"""
if self._glyph_map:
return self._glyph_map
cmap = self.get_character_map()
self._glyph_map = {}
for ch, glyph in cmap.items():
if not glyph in self._glyph_map:
self._glyph_map[glyph] = ch
return self._glyph_map
def get_character_map(self):
"""Return the character map.
Returns a dictionary where the key is a unit-length unicode
string and the value is a glyph index. Currently only
format 4 character maps are read.
"""
if self._character_map:
return self._character_map
cmap = _read_cmap_header(self._data, self._tables['cmap'].offset)
records = _read_cmap_encoding_record.array(self._data,
self._tables['cmap'].offset + cmap.size, cmap.num_tables)
self._character_map = {}
for record in records:
if record.platform_id == 3 and record.encoding_id == 1:
# Look at Windows Unicode charmaps only
offset = self._tables['cmap'].offset + record.offset
format_header = _read_cmap_format_header(self._data, offset)
if format_header.format == 4:
self._character_map = \
self._get_character_map_format4(offset)
break
return self._character_map
def _get_character_map_format4(self, offset):
# This is absolutely, without question, the *worst* file
# format ever. Whoever the fuckwit is that thought this up is
# a fuckwit.
header = _read_cmap_format4Header(self._data, offset)
seg_count = header.seg_count_x2 / 2
array_size = struct.calcsize('>%dH' % seg_count)
end_count = self._read_array('>%dH' % seg_count,
offset + header.size)
start_count = self._read_array('>%dH' % seg_count,
offset + header.size + array_size + 2)
id_delta = self._read_array('>%dh' % seg_count,
offset + header.size + array_size + 2 + array_size)
id_range_offset_address = \
offset + header.size + array_size + 2 + array_size + array_size
id_range_offset = self._read_array('>%dH' % seg_count,
id_range_offset_address)
character_map = {}
for i in range(0, seg_count):
if id_range_offset[i] != 0:
if id_range_offset[i] == 65535:
continue # Hack around a dodgy font (babelfish.ttf)
for c in range(start_count[i], end_count[i] + 1):
addr = id_range_offset[i] + 2*(c - start_count[i]) + \
id_range_offset_address + 2*i
g = struct.unpack('>H', self._data[addr:addr+2])[0]
if g != 0:
character_map[unichr(c)] = (g + id_delta[i]) % 65536
else:
for c in range(start_count[i], end_count[i] + 1):
g = (c + id_delta[i]) % 65536
if g != 0:
character_map[unichr(c)] = g
return character_map
def _read_array(self, format, offset):
size = struct.calcsize(format)
return struct.unpack(format, self._data[offset:offset+size])
def close(self):
"""Close the font file.
This is a good idea, since the entire file is memory mapped in
until this method is called. After closing cannot rely on the
``get_*`` methods.
"""
self._data.close()
os.close(self._fileno)
def _read_table(*entries):
""" Generic table constructor used for table formats listed at
end of file."""
fmt = '>'
names = []
for entry in entries:
name, type = entry.split(':')
names.append(name)
fmt += type
class _table_class:
size = struct.calcsize(fmt)
def __init__(self, data, offset):
items = struct.unpack(fmt, data[offset:offset+self.size])
self.pairs = zip(names, items)
for name, value in self.pairs:
setattr(self, name, value)
def __repr__(self):
s = '{' + ', '.join(['%s = %s' % (name, value) \
for name, value in self.pairs]) + '}'
return s
@staticmethod
def array(data, offset, count):
tables = []
for i in range(count):
tables.append(_table_class(data, offset))
offset += _table_class.size
return tables
return _table_class
# Table formats (see references)
_read_offset_table = _read_table('scalertype:I',
'num_tables:H',
'search_range:H',
'entry_selector:H',
'range_shift:H')
_read_table_directory_entry = _read_table('tag:4s',
'check_sum:I',
'offset:I',
'length:I')
_read_head_table = _read_table('version:i',
'font_revision:i',
'check_sum_adjustment:L',
'magic_number:L',
'flags:H',
'units_per_em:H',
'created:Q',
'modified:Q',
'x_min:h',
'y_min:h',
'x_max:h',
'y_max:h',
'mac_style:H',
'lowest_rec_p_pEM:H',
'font_direction_hint:h',
'index_to_loc_format:h',
'glyph_data_format:h')
_read_OS2_table = _read_table('version:H',
'x_avg_char_width:h',
'us_weight_class:H',
'us_width_class:H',
'fs_type:H',
'y_subscript_x_size:h',
'y_subscript_y_size:h',
'y_subscript_x_offset:h',
'y_subscript_y_offset:h',
'y_superscript_x_size:h',
'y_superscript_y_size:h',
'y_superscript_x_offset:h',
'y_superscript_y_offset:h',
'y_strikeout_size:h',
'y_strikeout_position:h',
's_family_class:h',
'panose1:B',
'panose2:B',
'panose3:B',
'panose4:B',
'panose5:B',
'panose6:B',
'panose7:B',
'panose8:B',
'panose9:B',
'panose10:B',
'ul_unicode_range1:L',
'ul_unicode_range2:L',
'ul_unicode_range3:L',
'ul_unicode_range4:L',
'ach_vend_id:I',
'fs_selection:H',
'us_first_char_index:H',
'us_last_char_index:H',
's_typo_ascender:h',
's_typo_descender:h',
's_typo_line_gap:h',
'us_win_ascent:H',
'us_win_descent:H',
'ul_code_page_range1:L',
'ul_code_page_range2:L',
'sx_height:h',
's_cap_height:h',
'us_default_char:H',
'us_break_char:H',
'us_max_context:H')
_read_kern_header_table = _read_table('version_num:H',
'n_tables:H')
_read_kern_subtable_header = _read_table('version:H',
'length:H',
'coverage:H')
_read_kern_subtable_header.horizontal_mask = 0x1
_read_kern_subtable_header.minimum_mask = 0x2
_read_kern_subtable_header.perpendicular_mask = 0x4
_read_kern_subtable_header.override_mask = 0x5
_read_kern_subtable_header.format_mask = 0xf0
_read_kern_subtable_format0 = _read_table('n_pairs:H',
'search_range:H',
'entry_selector:H',
'range_shift:H')
_read_kern_subtable_format0Pair = _read_table('left:H',
'right:H',
'value:h')
_read_cmap_header = _read_table('version:H',
'num_tables:H')
_read_cmap_encoding_record = _read_table('platform_id:H',
'encoding_id:H',
'offset:L')
_read_cmap_format_header = _read_table('format:H',
'length:H')
_read_cmap_format4Header = _read_table('format:H',
'length:H',
'language:H',
'seg_count_x2:H',
'search_range:H',
'entry_selector:H',
'range_shift:H')
_read_horizontal_header = _read_table('version:i',
'Advance:h',
'Descender:h',
'LineGap:h',
'advance_width_max:H',
'min_left_side_bearing:h',
'min_right_side_bearing:h',
'x_max_extent:h',
'caret_slope_rise:h',
'caret_slope_run:h',
'caret_offset:h',
'reserved1:h',
'reserved2:h',
'reserved3:h',
'reserved4:h',
'metric_data_format:h',
'number_of_h_metrics:H')
_read_long_hor_metric = _read_table('advance_width:H',
'lsb:h')
_read_naming_table = _read_table('format:H',
'count:H',
'string_offset:H')
_read_name_record = _read_table('platform_id:H',
'encoding_id:H',
'language_id:H',
'name_id:H',
'length:H',
'offset:H')
| Python |
"""
Query system Windows fonts with pure Python.
Public domain work by anatoly techtonik <techtonik@gmail.com>
Use MIT License if public domain doesn't make sense for you.
The task: Get monospace font for an application in the order of
preference.
A problem: Font ID in Windows is its name. Windows doesn't provide
any information about filenames they contained in. From two different
files with the same font name you can get only one.
Windows also doesn't have a clear concept of _generic font family_
familiar from CSS specification. Here is how fontquery maps Windows
LOGFONT properties to generic CSS font families:
serif - (LOGFONT.lfPitchAndFamily >> 4) == FF_ROMAN
sans-serif - (LOGFONT.lfPitchAndFamily >> 4) == FF_SWISS
cursive - (LOGFONT.lfPitchAndFamily >> 4) == FF_SCRIPT
fantasy - (LOGFONT.lfPitchAndFamily >> 4) == FF_DECORATIVE
monospace - (lf.lfPitchAndFamily & 0b11) == FIXED_PITCH
NOTE: ATM, May 2015, the Microsoft documentation related to monospace
is misleading due to poor wording:
- FF_MODERN in the description of LOGFONT structure tells
"Fonts with constant stroke width (monospace), with or without serifs.
Monospace fonts are usually modern.
Pica, Elite, and CourierNew are examples.
"
Stroke width is the 'pen width', not glyph width. It should read
"Fonts with constant stroke width, with or without serifs.
Monospace fonts are usually modern, but not all modern are monospace
"
PYGLET NOTE:
Examination of all fonts in a windows xp machine shows that all fonts
with
fontentry.vector and fontentry.family != FF_DONTCARE
are rendered fine.
Use cases:
[x] get the list of all available system font names
[ ] get the list of all fonts for generic family
[ ] get the list of all fonts for specific charset
[ ] check if specific font is available
Considerations:
- performance of querying all system fonts is not measured
- Windows doesn't allow to get filenames of the fonts, so if there
are two fonts with the same name, one will be missing
MSDN:
If you request a font named Palatino, but no such font is available
on the system, the font mapper will substitute a font that has similar
attributes but a different name.
[ ] check if font chosen by the system has required family
To get the appropriate font, call EnumFontFamiliesEx with the
desired font characteristics in the LOGFONT structure, then retrieve the
appropriate typeface name and create the font using CreateFont or
CreateFontIndirect.
"""
DEBUG = False
__all__ = ['have_font', 'font_list']
__version__ = '0.3'
__url__ = 'https://bitbucket.org/techtonik/fontquery'
import sys
PY3K = sys.version_info >= (3, 0)
#-- INTRO: MAINTAIN CACHED FONTS DB --
# [ ] make it Django/NDB style model definition
class FontEntry(object):
"""
Font classification.
Level 0:
- name
- vector (True if font is vector, False for raster fonts)
- format: ttf | ...
"""
def __init__(self, name, vector, format, monospace, family):
self.name = name
self.vector = vector
self.format = format
self.monospace = monospace
self.family = family
# List of FontEntry objects
FONTDB = []
#-- CHAPTER 1: GET ALL SYSTEM FONTS USING EnumFontFamiliesEx FROM GDI --
"""
Q: Why GDI? Why not GDI+?
A: Wikipedia:
Because of the additional text processing and resolution independence
capabilities in GDI+, text rendering is performed by the CPU [2] and it
is nearly an order of magnitude slower than in hardware accelerated GDI.[3]
Chris Jackson published some tests indicating that a piece of text
rendering code he had written could render 99,000 glyphs per second in GDI,
but the same code using GDI+ rendered 16,600 glyphs per second.
"""
import ctypes
from ctypes import wintypes
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32
# --- define necessary data structures from wingdi.h
# for calling ANSI functions of Windows API (end with A) TCHAR is
# defined as single char, for Unicode ones (end witn W) it is WCHAR
CHAR = ctypes.c_char # Python 2.7 compatibility
TCHAR = CHAR
BYTE = ctypes.c_ubyte # http://bugs.python.org/issue16376
# charset codes for LOGFONT structure
ANSI_CHARSET = 0
ARABIC_CHARSET = 178
BALTIC_CHARSET = 186
CHINESEBIG5_CHARSET = 136
DEFAULT_CHARSET = 1
# - charset for current system locale -
# means function can be called several times
# for the single font (for each charset)
EASTEUROPE_CHARSET = 238
GB2312_CHARSET = 134
GREEK_CHARSET = 161
HANGUL_CHARSET = 129
HEBREW_CHARSET = 177
JOHAB_CHARSET = 130
MAC_CHARSET = 77
OEM_CHARSET = 255 # OS dependent system charset
RUSSIAN_CHARSET = 204
SHIFTJIS_CHARSET = 128
SYMBOL_CHARSET = 2
THAI_CHARSET = 222
TURKISH_CHARSET = 162
VIETNAMESE_CHARSET = 163
# build lookup dictionary to get charset name from its code
CHARSET_NAMES = {}
for (name, value) in locals().copy().items():
if name.endswith('_CHARSET'):
CHARSET_NAMES[value] = name
# font pitch constants ('fixed pitch' means 'monospace')
DEFAULT_PITCH = 0
FIXED_PITCH = 1
VARIABLE_PITCH = 2
# Windows font family constants
FF_DONTCARE = 0 # Don't care or don't know
FF_ROMAN = 1 # with serifs, proportional
FF_SWISS = 2 # w/out serifs, proportional
FF_MODERN = 3 # constant stroke width
FF_SCRIPT = 4 # handwritten
FF_DECORATIVE = 5 # novelty
class LOGFONT(ctypes.Structure):
# EnumFontFamiliesEx examines only 3 fields:
# - lfCharSet
# - lfFaceName - empty string enumerates one font in each available
# typeface name, valid typeface name gets all fonts
# with that name
# - lfPitchAndFamily - must be set to 0 [ ]
_fields_ = [
('lfHeight', wintypes.LONG),
# value > 0 specifies the largest size of *char cell* to match
# char cell = char height + internal leading
# value = 0 makes matched use default height for search
# value < 0 specifies the largest size of *char height* to match
('lfWidth', wintypes.LONG),
# average width also in *logical units*, which are pixels in
# default _mapping mode_ (MM_TEXT) for device
('lfEscapement', wintypes.LONG),
# string baseline rotation in tenths of degrees
('lfOrientation', wintypes.LONG),
# character rotation in tenths of degrees
('lfWeight', wintypes.LONG),
# 0 through 1000 400 is normal, 700 is bold, 0 is default
('lfItalic', BYTE),
('lfUnderline', BYTE),
('lfStrikeOut', BYTE),
('lfCharSet', BYTE),
# ANSI_CHARSET, BALTIC_CHARSET, ... - see *_CHARSET constants above
('lfOutPrecision', BYTE),
# many constants how the output must match height, width, pitch etc.
# OUT_DEFAULT_PRECIS
# [ ] TODO
('lfClipPrecision', BYTE),
# how to clip characters, no useful properties, leave default value
# CLIP_DEFAULT_PRECIS
('lfQuality', BYTE),
# ANTIALIASED_QUALITY
# CLEARTYPE_QUALITY
# DEFAULT_QUALITY
# DRAFT_QUALITY
# NONANTIALIASED_QUALITY
# PROOF_QUALITY
('lfPitchAndFamily', BYTE),
# DEFAULT_PITCH
# FIXED_PITCH - authoritative for monospace
# VARIABLE_PITCH
# stacked with any of
# FF_DECORATIVE - novelty
# FF_DONTCARE - default font
# FF_MODERN - stroke width ('pen width') near constant
# FF_ROMAN - proportional (variable char width) with serifs
# FF_SCRIPT - handwritten
# FF_SWISS - proportional without serifs
('lfFaceName', TCHAR*32)]
# typeface name of the font - null-terminated string
class FONTSIGNATURE(ctypes.Structure):
# supported code pages and Unicode subranges for the font
# needed for NEWTEXTMETRICEX structure
_fields_ = [
('sUsb', wintypes.DWORD*4), # 128-bit Unicode subset bitfield (USB)
('sCsb', wintypes.DWORD*2)] # 64-bit, code-page bitfield (CPB)
class NEWTEXTMETRIC(ctypes.Structure):
# physical font attributes for True Type fonts
# needed for NEWTEXTMETRICEX structure
_fields_ = [
('tmHeight', wintypes.LONG),
('tmAscent', wintypes.LONG),
('tmDescent', wintypes.LONG),
('tmInternalLeading', wintypes.LONG),
('tmExternalLeading', wintypes.LONG),
('tmAveCharWidth', wintypes.LONG),
('tmMaxCharWidth', wintypes.LONG),
('tmWeight', wintypes.LONG),
('tmOverhang', wintypes.LONG),
('tmDigitizedAspectX', wintypes.LONG),
('tmDigitizedAspectY', wintypes.LONG),
('mFirstChar', TCHAR),
('mLastChar', TCHAR),
('mDefaultChar', TCHAR),
('mBreakChar', TCHAR),
('tmItalic', BYTE),
('tmUnderlined', BYTE),
('tmStruckOut', BYTE),
('tmPitchAndFamily', BYTE),
('tmCharSet', BYTE),
('tmFlags', wintypes.DWORD),
('ntmSizeEM', wintypes.UINT),
('ntmCellHeight', wintypes.UINT),
('ntmAvgWidth', wintypes.UINT)]
class NEWTEXTMETRICEX(ctypes.Structure):
# physical font attributes for True Type fonts
# needed for FONTENUMPROC callback function
_fields_ = [
('ntmTm', NEWTEXTMETRIC),
('ntmFontSig', FONTSIGNATURE)]
# type for a function that is called by the system for
# each font during execution of EnumFontFamiliesEx
FONTENUMPROC = ctypes.WINFUNCTYPE(
ctypes.c_int, # return non-0 to continue enumeration, 0 to stop
ctypes.POINTER(LOGFONT),
ctypes.POINTER(NEWTEXTMETRICEX),
wintypes.DWORD, # font type, a combination of
# DEVICE_FONTTYPE
# RASTER_FONTTYPE
# TRUETYPE_FONTTYPE
wintypes.LPARAM
)
def _enum_font_names(logfont, textmetricex, fonttype, param):
"""callback function to be executed during EnumFontFamiliesEx
call for each font name. it stores names in global variable
"""
global FONTDB
lf = logfont.contents
name = lf.lfFaceName
if PY3K:
# [ ] check this works
name = name.decode('utf-8')
# detect font type (vector|raster) and format (ttf)
# [ ] use Windows constant TRUETYPE_FONTTYPE
if fonttype & 4:
vector = True
format = 'ttf'
else:
vector = False
# [ ] research Windows raster format structure
format = 'unknown'
pitch = lf.lfPitchAndFamily & 0b11
family = lf.lfPitchAndFamily >> 4
# [ ] check FIXED_PITCH, VARIABLE_PITCH and FF_MODERN
# combination
#
# FP T NM 400 CHARSET: 0 DFKai-SB
# FP T NM 400 CHARSET: 136 DFKai-SB
# FP T NM 400 CHARSET: 0 @DFKai-SB
# FP T NM 400 CHARSET: 136 @DFKai-SB
# VP T M 400 CHARSET: 0 OCR A Extended
monospace = (pitch == FIXED_PITCH)
charset = lf.lfCharSet
FONTDB.append(FontEntry(name, vector, format, monospace, family))
if DEBUG:
info = ''
if pitch == FIXED_PITCH:
info += 'FP '
elif pitch == VARIABLE_PITCH:
info += 'VP '
else:
info += ' '
# [ ] check exact fonttype values meaning
info += '%s ' % {0:'U', 1:'R', 4:'T'}[fonttype]
if monospace:
info += 'M '
else:
info += 'NM '
style = [' ']*3
if lf.lfItalic:
style[0] = 'I'
if lf.lfUnderline:
style[1] = 'U'
if lf.lfStrikeOut:
style[2] = 'S'
info += ''.join(style)
info += ' %s' % lf.lfWeight
#if pitch == FIXED_PITCH:
if 1:
print '%s CHARSET: %3s %s' % (info, lf.lfCharSet, lf.lfFaceName)
return 1 # non-0 to continue enumeration
enum_font_names = FONTENUMPROC(_enum_font_names)
# --- /define
# --- prepare and call EnumFontFamiliesEx
def query(charset=DEFAULT_CHARSET):
"""
Prepare and call EnumFontFamiliesEx.
query()
- return tuple with sorted list of all available system fonts
query(charset=ANSI_CHARSET)
- return tuple sorted list of system fonts supporting ANSI charset
"""
global FONTDB
# 1. Get device context of the entire screen
hdc = user32.GetDC(None)
# 2. Call EnumFontFamiliesExA (ANSI version)
# 2a. Call with empty font name to query all available fonts
# (or fonts for the specified charset)
#
# NOTES:
#
# * there are fonts that don't support ANSI charset
# * for DEFAULT_CHARSET font is passed to callback function as
# many times as charsets it supports
# [ ] font name should be less than 32 symbols with terminating \0
# [ ] check double purpose - enumerate all available font names
# - enumerate all available charsets for a single font
# - other params?
logfont = LOGFONT(0, 0, 0, 0, 0, 0, 0, 0, charset,
0, 0, 0, 0, b'\0')
FONTDB = [] # clear cached FONTDB for enum_font_names callback
res = gdi32.EnumFontFamiliesExA(
hdc, # handle to device context
ctypes.byref(logfont),
enum_font_names, # pointer to callback function
0, # lParam - application-supplied data
0) # dwFlags - reserved = 0
# res here is the last value returned by callback function
# 3. Release DC
user32.ReleaseDC(None, hdc)
return FONTDB
# --- Public API ---
def have_font(name, refresh=False):
"""
Return True if font with specified `name` is present. The result
of querying system font names is cached. Set `refresh` parameter
to True to purge cache and reload font information.
"""
if not FONTDB or refresh:
query()
if any(f.name == name for f in FONTDB):
return True
else:
return False
def font_list(vector_only=False, monospace_only=False):
"""Return list of system installed font names."""
if not FONTDB:
query()
fonts = FONTDB
if vector_only:
fonts = [f for f in fonts if f.vector]
if monospace_only:
fonts = [f for f in fonts if f.monospace]
return sorted([f.name for f in fonts])
if __name__ == '__main__':
import sys
if sys.argv[1:] == ['debug']:
DEBUG = True
if sys.argv[1:] == ['test'] or DEBUG:
print 'Running tests..'
# test have_font (Windows)
test_arial = have_font('Arial')
print 'Have font "Arial"? %s' % test_arial
print 'Have font "missing-one"? %s' % have_font('missing-one')
# test cache is not rebuilt
FONTDB = [FontEntry('stub', False, '', False, FF_MODERN)]
assert(have_font('Arial') != test_arial)
# test cache is rebiult
assert(have_font('Arial', refresh=True) == test_arial)
if not DEBUG:
sys.exit()
if sys.argv[1:] == ['vector']:
fonts = font_list(vector_only=True)
elif sys.argv[1:] == ['mono']:
fonts = font_list(monospace_only=True)
elif sys.argv[1:] == ['vector','mono']:
fonts = font_list(vector_only=True, monospace_only=True)
else:
fonts = font_list()
print '\n'.join(fonts)
if DEBUG:
print "Total: %s" % len(font_list())
#-- CHAPTER 2: WORK WITH FONT DIMENSIONS --
#
# Essential info about font metrics http://support.microsoft.com/kb/32667
# And about logical units at http://www.winprog.org/tutorial/fonts.html
# x. Convert desired font size from points into logical units (pixels)
# By default logical for the screen units are pixels. This is defined
# by default MM_TEXT mapping mode.
# Point is ancient unit of measurement for physical size of a font.
# 10pt is equal to 3.527mm. To make sure a char on screen has physical
# size equal to 3.527mm, we need to know display size to calculate how
# many pixels are in 3.527mm, and then fetch font that best matches
# this size.
# Essential info about conversion http://support.microsoft.com/kb/74299
# x.1 Get pixels per inch using GetDeviceCaps() or ...
#-- CHAPTER 3: LAYERED FONT API --
#
# y. Font object with several layers of info
# Font object should contains normalized font information. This
# information is split according to usage. For example, level 0 property
# is font id - its name. Level 1 can be information about loaded font
# characters - in pyglet it could be cached/used glyphs and video memory
# taken by those glyphs.
# [ ] (pyglet) investigate if it is possible to get video memory size
# occupied by the font glyphs
# [ ] (pyglet) investigate if it is possible to unload font from video
# memory if its unused
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
# TODO Windows Vista: need to call SetProcessDPIAware? May affect GDI+ calls
# as well as font.
from ctypes import *
import ctypes
import math
from sys import byteorder
import pyglet
from pyglet.font import base
from pyglet.font import win32query
import pyglet.image
from pyglet.libs.win32.constants import *
from pyglet.libs.win32.types import *
from pyglet.libs.win32 import _gdi32 as gdi32, _user32 as user32
from pyglet.libs.win32 import _kernel32 as kernel32
from pyglet.compat import asbytes
_debug_font = pyglet.options['debug_font']
def str_ucs2(text):
if byteorder == 'big':
text = text.encode('utf_16_be')
else:
text = text.encode('utf_16_le') # explicit endian avoids BOM
return create_string_buffer(text + '\0')
_debug_dir = 'debug_font'
def _debug_filename(base, extension):
import os
if not os.path.exists(_debug_dir):
os.makedirs(_debug_dir)
name = '%s-%%d.%%s' % os.path.join(_debug_dir, base)
num = 1
while os.path.exists(name % (num, extension)):
num += 1
return name % (num, extension)
def _debug_image(image, name):
filename = _debug_filename(name, 'png')
image.save(filename)
_debug('Saved image %r to %s' % (image, filename))
_debug_logfile = None
def _debug(msg):
global _debug_logfile
if not _debug_logfile:
_debug_logfile = open(_debug_filename('log', 'txt'), 'wt')
_debug_logfile.write(msg + '\n')
class Win32GlyphRenderer(base.GlyphRenderer):
_bitmap = None
_dc = None
_bitmap_rect = None
def __init__(self, font):
super(Win32GlyphRenderer, self).__init__(font)
self.font = font
# Pessimistically round up width and height to 4 byte alignment
width = font.max_glyph_width
height = font.ascent - font.descent
width = (width | 0x3) + 1
height = (height | 0x3) + 1
self._create_bitmap(width, height)
gdi32.SelectObject(self._dc, self.font.hfont)
def _create_bitmap(self, width, height):
pass
def render(self, text):
raise NotImplementedError('abstract')
class GDIGlyphRenderer(Win32GlyphRenderer):
def __del__(self):
try:
if self._dc:
gdi32.DeleteDC(self._dc)
if self._bitmap:
gdi32.DeleteObject(self._bitmap)
except:
pass
def render(self, text):
# Attempt to get ABC widths (only for TrueType)
abc = ABC()
if gdi32.GetCharABCWidthsW(self._dc,
ord(text), ord(text), byref(abc)):
width = abc.abcB
lsb = abc.abcA
advance = abc.abcA + abc.abcB + abc.abcC
else:
width_buf = c_int()
gdi32.GetCharWidth32W(self._dc,
ord(text), ord(text), byref(width_buf))
width = width_buf.value
lsb = 0
advance = width
# Can't get glyph-specific dimensions, use whole line-height.
height = self._bitmap_height
image = self._get_image(text, width, height, lsb)
glyph = self.font.create_glyph(image)
glyph.set_bearings(-self.font.descent, lsb, advance)
if _debug_font:
_debug('%r.render(%s)' % (self, text))
_debug('abc.abcA = %r' % abc.abcA)
_debug('abc.abcB = %r' % abc.abcB)
_debug('abc.abcC = %r' % abc.abcC)
_debug('width = %r' % width)
_debug('height = %r' % height)
_debug('lsb = %r' % lsb)
_debug('advance = %r' % advance)
_debug_image(image, 'glyph_%s' % text)
_debug_image(self.font.textures[0], 'tex_%s' % text)
return glyph
def _get_image(self, text, width, height, lsb):
# There's no such thing as a greyscale bitmap format in GDI. We can
# create an 8-bit palette bitmap with 256 shades of grey, but
# unfortunately antialiasing will not work on such a bitmap. So, we
# use a 32-bit bitmap and use the red channel as OpenGL's alpha.
gdi32.SelectObject(self._dc, self._bitmap)
gdi32.SelectObject(self._dc, self.font.hfont)
gdi32.SetBkColor(self._dc, 0x0)
gdi32.SetTextColor(self._dc, 0x00ffffff)
gdi32.SetBkMode(self._dc, OPAQUE)
# Draw to DC
user32.FillRect(self._dc, byref(self._bitmap_rect), self._black)
gdi32.ExtTextOutA(self._dc, -lsb, 0, 0, None, text,
len(text), None)
gdi32.GdiFlush()
# Create glyph object and copy bitmap data to texture
image = pyglet.image.ImageData(width, height,
'AXXX', self._bitmap_data, self._bitmap_rect.right * 4)
return image
def _create_bitmap(self, width, height):
self._black = gdi32.GetStockObject(BLACK_BRUSH)
self._white = gdi32.GetStockObject(WHITE_BRUSH)
if self._dc:
gdi32.ReleaseDC(self._dc)
if self._bitmap:
gdi32.DeleteObject(self._bitmap)
pitch = width * 4
data = POINTER(c_byte * (height * pitch))()
info = BITMAPINFO()
info.bmiHeader.biSize = sizeof(info.bmiHeader)
info.bmiHeader.biWidth = width
info.bmiHeader.biHeight = height
info.bmiHeader.biPlanes = 1
info.bmiHeader.biBitCount = 32
info.bmiHeader.biCompression = BI_RGB
self._dc = gdi32.CreateCompatibleDC(None)
self._bitmap = gdi32.CreateDIBSection(None,
byref(info), DIB_RGB_COLORS, byref(data), None,
0)
# Spookiness: the above line causes a "not enough storage" error,
# even though that error cannot be generated according to docs,
# and everything works fine anyway. Call SetLastError to clear it.
kernel32.SetLastError(0)
self._bitmap_data = data.contents
self._bitmap_rect = RECT()
self._bitmap_rect.left = 0
self._bitmap_rect.right = width
self._bitmap_rect.top = 0
self._bitmap_rect.bottom = height
self._bitmap_height = height
if _debug_font:
_debug('%r._create_dc(%d, %d)' % (self, width, height))
_debug('_dc = %r' % self._dc)
_debug('_bitmap = %r' % self._bitmap)
_debug('pitch = %r' % pitch)
_debug('info.bmiHeader.biSize = %r' % info.bmiHeader.biSize)
class Win32Font(base.Font):
glyph_renderer_class = GDIGlyphRenderer
def __init__(self, name, size, bold=False, italic=False, dpi=None):
super(Win32Font, self).__init__()
self.logfont = self.get_logfont(name, size, bold, italic, dpi)
self.hfont = gdi32.CreateFontIndirectA(byref(self.logfont))
# Create a dummy DC for coordinate mapping
dc = user32.GetDC(0)
metrics = TEXTMETRIC()
gdi32.SelectObject(dc, self.hfont)
gdi32.GetTextMetricsA(dc, byref(metrics))
self.ascent = metrics.tmAscent
self.descent = -metrics.tmDescent
self.max_glyph_width = metrics.tmMaxCharWidth
@staticmethod
def get_logfont(name, size, bold, italic, dpi):
# Create a dummy DC for coordinate mapping
dc = user32.GetDC(0)
if dpi is None:
dpi = 96
logpixelsy = dpi
logfont = LOGFONT()
# Conversion of point size to device pixels
logfont.lfHeight = int(-size * logpixelsy // 72)
if bold:
logfont.lfWeight = FW_BOLD
else:
logfont.lfWeight = FW_NORMAL
logfont.lfItalic = italic
logfont.lfFaceName = asbytes(name)
logfont.lfQuality = ANTIALIASED_QUALITY
return logfont
@classmethod
def have_font(cls, name):
# [ ] add support for loading raster fonts
return win32query.have_font(name)
@classmethod
def add_font_data(cls, data):
numfonts = c_uint32()
gdi32.AddFontMemResourceEx(data, len(data), 0, byref(numfonts))
# --- GDI+ font rendering ---
from pyglet.image.codecs.gdiplus import PixelFormat32bppARGB, gdiplus, Rect
from pyglet.image.codecs.gdiplus import ImageLockModeRead, BitmapData
DriverStringOptionsCmapLookup = 1
DriverStringOptionsRealizedAdvance = 4
TextRenderingHintAntiAlias = 4
TextRenderingHintAntiAliasGridFit = 3
StringFormatFlagsDirectionRightToLeft = 0x00000001
StringFormatFlagsDirectionVertical = 0x00000002
StringFormatFlagsNoFitBlackBox = 0x00000004
StringFormatFlagsDisplayFormatControl = 0x00000020
StringFormatFlagsNoFontFallback = 0x00000400
StringFormatFlagsMeasureTrailingSpaces = 0x00000800
StringFormatFlagsNoWrap = 0x00001000
StringFormatFlagsLineLimit = 0x00002000
StringFormatFlagsNoClip = 0x00004000
class Rectf(ctypes.Structure):
_fields_ = [
('x', ctypes.c_float),
('y', ctypes.c_float),
('width', ctypes.c_float),
('height', ctypes.c_float),
]
class GDIPlusGlyphRenderer(Win32GlyphRenderer):
def _create_bitmap(self, width, height):
self._data = (ctypes.c_byte * (4 * width * height))()
self._bitmap = ctypes.c_void_p()
self._format = PixelFormat32bppARGB
gdiplus.GdipCreateBitmapFromScan0(width, height, width * 4,
self._format, self._data, ctypes.byref(self._bitmap))
self._graphics = ctypes.c_void_p()
gdiplus.GdipGetImageGraphicsContext(self._bitmap,
ctypes.byref(self._graphics))
gdiplus.GdipSetPageUnit(self._graphics, UnitPixel)
self._dc = user32.GetDC(0)
gdi32.SelectObject(self._dc, self.font.hfont)
gdiplus.GdipSetTextRenderingHint(self._graphics,
TextRenderingHintAntiAliasGridFit)
self._brush = ctypes.c_void_p()
gdiplus.GdipCreateSolidFill(0xffffffff, ctypes.byref(self._brush))
self._matrix = ctypes.c_void_p()
gdiplus.GdipCreateMatrix(ctypes.byref(self._matrix))
self._flags = (DriverStringOptionsCmapLookup |
DriverStringOptionsRealizedAdvance)
self._rect = Rect(0, 0, width, height)
self._bitmap_height = height
def render(self, text):
ch = ctypes.create_unicode_buffer(text)
len_ch = len(text)
# Layout rectangle; not clipped against so not terribly important.
width = 10000
height = self._bitmap_height
rect = Rectf(0, self._bitmap_height
- self.font.ascent + self.font.descent,
width, height)
# Set up GenericTypographic with 1 character measure range
generic = ctypes.c_void_p()
gdiplus.GdipStringFormatGetGenericTypographic(ctypes.byref(generic))
format = ctypes.c_void_p()
gdiplus.GdipCloneStringFormat(generic, ctypes.byref(format))
# Measure advance
bbox = Rectf()
flags = (StringFormatFlagsMeasureTrailingSpaces |
StringFormatFlagsNoClip |
StringFormatFlagsNoFitBlackBox)
gdiplus.GdipSetStringFormatFlags(format, flags)
gdiplus.GdipMeasureString(self._graphics, ch, len_ch,
self.font._gdipfont, ctypes.byref(rect), format,
ctypes.byref(bbox), None, None)
lsb = 0
advance = int(math.ceil(bbox.width))
# XXX HACK HACK HACK
# Windows GDI+ is a filthy broken toy. No way to measure the bounding
# box of a string, or to obtain LSB. What a joke.
#
# For historical note, GDI cannot be used because it cannot composite
# into a bitmap with alpha.
#
# It looks like MS have abandoned GDI and GDI+ and are finally
# supporting accurate text measurement with alpha composition in .NET
# 2.0 (WinForms) via the TextRenderer class; this has no C interface
# though, so we're entirely screwed.
#
# So anyway, this hack bumps up the width if the font is italic;
# this compensates for some common fonts. It's also a stupid waste of
# texture memory.
width = advance
if self.font.italic:
width += width // 2
# XXX END HACK HACK HACK
# Draw character to bitmap
gdiplus.GdipGraphicsClear(self._graphics, 0x00000000)
gdiplus.GdipDrawString(self._graphics, ch, len_ch,
self.font._gdipfont, ctypes.byref(rect), format,
self._brush)
gdiplus.GdipFlush(self._graphics, 1)
bitmap_data = BitmapData()
gdiplus.GdipBitmapLockBits(self._bitmap,
byref(self._rect), ImageLockModeRead, self._format,
byref(bitmap_data))
# Create buffer for RawImage
buffer = create_string_buffer(
bitmap_data.Stride * bitmap_data.Height)
memmove(buffer, bitmap_data.Scan0, len(buffer))
# Unlock data
gdiplus.GdipBitmapUnlockBits(self._bitmap, byref(bitmap_data))
image = pyglet.image.ImageData(width, height,
'BGRA', buffer, -bitmap_data.Stride)
glyph = self.font.create_glyph(image)
glyph.set_bearings(-self.font.descent, lsb, advance)
return glyph
FontStyleBold = 1
FontStyleItalic = 2
UnitPixel = 2
UnitPoint = 3
class GDIPlusFont(Win32Font):
glyph_renderer_class = GDIPlusGlyphRenderer
_private_fonts = None
_default_name = 'Arial'
def __init__(self, name, size, bold=False, italic=False, dpi=None):
if not name:
name = self._default_name
super(GDIPlusFont, self).__init__(name, size, bold, italic, dpi)
family = ctypes.c_void_p()
name = ctypes.c_wchar_p(name)
# Look in private collection first:
if self._private_fonts:
gdiplus.GdipCreateFontFamilyFromName(name,
self._private_fonts, ctypes.byref(family))
# Then in system collection:
if not family:
gdiplus.GdipCreateFontFamilyFromName(name,
None, ctypes.byref(family))
# Nothing found, use default font.
if not family:
name = self._default_name
gdiplus.GdipCreateFontFamilyFromName(ctypes.c_wchar_p(name),
None, ctypes.byref(family))
if dpi is None:
unit = UnitPoint
self.dpi = 96
else:
unit = UnitPixel
size = (size * dpi) // 72
self.dpi = dpi
style = 0
if bold:
style |= FontStyleBold
if italic:
style |= FontStyleItalic
self.italic = italic # XXX needed for HACK HACK HACK
self._gdipfont = ctypes.c_void_p()
gdiplus.GdipCreateFont(family, ctypes.c_float(size),
style, unit, ctypes.byref(self._gdipfont))
@classmethod
def add_font_data(cls, data):
super(GDIPlusFont, cls).add_font_data(data)
if not cls._private_fonts:
cls._private_fonts = ctypes.c_void_p()
gdiplus.GdipNewPrivateFontCollection(
ctypes.byref(cls._private_fonts))
gdiplus.GdipPrivateAddMemoryFont(cls._private_fonts, data, len(data))
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
# TODO Tiger and later: need to set kWindowApplicationScaledAttribute for DPI
# independence?
from ctypes import *
import math
from sys import byteorder
from pyglet.font import base
import pyglet.image
from pyglet.libs.darwin import *
from pyglet.libs.darwin import _oscheck
class FixedPoint(Structure):
_fields_ = [
('x', Fixed),
('y', Fixed)
]
class ATSTrapezoid(Structure):
_fields_ = [
('upperLeft', FixedPoint),
('upperRight', FixedPoint),
('lowerRight', FixedPoint),
('lowerLeft', FixedPoint)
]
# TODO: most of the ATS and CG here not used any more.
CGGlyph = c_ushort
ATSUFontID = c_uint32
RGBColor = c_short * 3
ATSURGBAlphaColor = c_float * 4
kCGImageAlphaNone = 0
kCGImageAlphaPremultipliedLast = 1
kCGTextFill = 0
kATSUInvalidFontErr = -8796
kATSFontContextUnspecified = 0
kATSFontContextGlobal = 1
kATSFontContextLocal = 2
kATSFontFilterSelectorUnspecified = 0
kATSFontFilterSelectorGeneration = 3
kATSFontFilterSelectorFontFamily = 7
kATSFontFilterSelectorFontFamilyApplierFunction = 8
kATSFontFilterSelectorFontApplierFunction = 9
kATSOptionFlagsDoNotNotify = 0x00000001 << 8
kATSOptionFlagsIterationScopeMask = 0x00000007 << 12
kATSOptionFlagsDefaultScope = 0x00000000 << 12
kATSOptionFlagsUnRestrictedScope = 0x00000001 << 12
kATSOptionFlagsRestrictedScope = 0x00000002 << 12
kATSOptionFlagsProcessSubdirectories = 0x00000001 << 6
kATSUFromTextBeginning = c_ulong(0xFFFFFFFF)
kATSUToTextEnd = c_ulong(0xFFFFFFFF)
kATSULineAscentTag = 8
kATSULineDescentTag = 9
ATSUTextMeasurement = Fixed
kATSUQDBoldfaceTag = 256
kATSUQDItalicTag = 257
kATSUFontTag = 261
kATSUSizeTag = 262
kATSUCGContextTag = 32767
kATSUColorTag = 263
kATSURGBAlphaColorTag = 288
kATSULineWidthTag = 1
kFontFullName = 4
kFontNoPlatformCode = c_ulong(-1)
kFontNoScriptCode = c_ulong(-1)
kFontNoLanguageCode = c_ulong(-1)
kATSUseDeviceOrigins = 1
kATSFontFormatUnspecified = 0
kATSFontContextLocal = 2
carbon.CGColorSpaceCreateWithName.restype = c_void_p
carbon.CGBitmapContextCreate.restype = POINTER(c_void_p)
UniCharArrayOffset = c_uint32
UniCharCount = c_uint32
kATSULayoutOperationJustification = 1
kATSULayoutOperationPostLayoutAdjustment = 0x20
kATSULayoutOperationCallbackStatusHandled = 0
kATSULayoutOperationCallbackStatusContinue = c_long(1)
kATSULayoutOperationOverrideTag = 15
kATSUDirectDataAdvanceDeltaFixedArray = 0
kATSUDirectDataDeviceDeltaSInt16Array = 2
kATSUDirectDataLayoutRecordATSLayoutRecordVersion1 = 100
ATSUDirectLayoutOperationOverrideUPP = CFUNCTYPE(c_int,
c_int, c_void_p, c_uint32, c_void_p, POINTER(c_int))
class ATSULayoutOperationOverrideSpecifier(Structure):
_fields_ = [
('operationSelector', c_uint32),
('overrideUPP', ATSUDirectLayoutOperationOverrideUPP)
]
class ATSLayoutRecord(Structure):
_pack_ = 2
_fields_ = [
('glyphID', c_uint16),
('flags', c_uint32),
('originalOffset', c_uint32),
('realPos', Fixed),
]
def fixed(value):
return c_int32(carbon.Long2Fix(c_long(int(value))))
carbon.Fix2X.restype = c_double
def fix2float(value):
return carbon.Fix2X(value)
def create_atsu_style(attributes):
# attributes is a dict of ATSUAttributeTag => ctypes value
tags, values = zip(*attributes.items())
tags = (c_int * len(tags))(*tags)
sizes = (c_uint * len(values))(*[sizeof(v) for v in values])
values = (c_void_p * len(values))(*[cast(pointer(v), c_void_p) \
for v in values])
style = c_void_p()
carbon.ATSUCreateStyle(byref(style))
carbon.ATSUSetAttributes(style, len(tags), tags, sizes, values)
return style
def set_layout_attributes(layout, attributes):
if attributes:
# attributes is a dict of ATSUAttributeTag => ctypes value
tags, values = zip(*attributes.items())
tags = (c_int * len(tags))(*tags)
sizes = (c_uint * len(values))(*[sizeof(v) for v in values])
values = (c_void_p * len(values))(*[cast(pointer(v), c_void_p) \
for v in values])
r = carbon.ATSUSetLayoutControls(layout, len(tags), tags, sizes, values)
_oscheck(r)
def str_ucs2(text):
if byteorder == 'big':
text = text.encode('utf_16_be')
else:
text = text.encode('utf_16_le') # explicit endian avoids BOM
return create_string_buffer(text + '\0')
class CarbonGlyphRenderer(base.GlyphRenderer):
_bitmap = None
_bitmap_context = None
_bitmap_rect = None
_glyph_advance = 0 # set through callback
def __init__(self, font):
super(CarbonGlyphRenderer, self).__init__(font)
self._create_bitmap_context(256, 256)
self.font = font
def __del__(self):
try:
if self._bitmap_context:
carbon.CGContextRelease(self._bitmap_context)
except:
pass
def _layout_callback(self, operation, line, ref, extra, callback_status):
if not line:
return 0
records = c_void_p()
n_records = c_uint()
r = carbon.ATSUDirectGetLayoutDataArrayPtrFromLineRef(line,
kATSUDirectDataLayoutRecordATSLayoutRecordVersion1,
0,
byref(records),
byref(n_records))
_oscheck(r)
records = cast(records,
POINTER(ATSLayoutRecord * n_records.value)).contents
self._glyph_advance = fix2float(records[-1].realPos)
callback_status.contents = kATSULayoutOperationCallbackStatusContinue
return 0
def render(self, text):
# Convert text to UCS2
text_len = len(text)
text_ucs2 = str_ucs2(text)
# Create layout override handler to extract device advance value.
override_spec = ATSULayoutOperationOverrideSpecifier()
override_spec.operationSelector = \
kATSULayoutOperationPostLayoutAdjustment
override_spec.overrideUPP = \
ATSUDirectLayoutOperationOverrideUPP(self._layout_callback)
# Create ATSU text layout for this text and font
layout = c_void_p()
carbon.ATSUCreateTextLayout(byref(layout))
set_layout_attributes(layout, {
kATSUCGContextTag: self._bitmap_context,
kATSULayoutOperationOverrideTag: override_spec})
carbon.ATSUSetTextPointerLocation(layout,
text_ucs2,
kATSUFromTextBeginning,
kATSUToTextEnd,
text_len)
carbon.ATSUSetRunStyle(layout, self.font.atsu_style,
kATSUFromTextBeginning, kATSUToTextEnd)
# Turning on transient font matching screws up font layout
# predictability when strange fonts are installed
# <ah> Don't believe this. Can't get foreign/special characters
# without transient on.
carbon.ATSUSetTransientFontMatching(layout, True)
# Get bitmap dimensions required
rect = Rect()
carbon.ATSUMeasureTextImage(layout,
kATSUFromTextBeginning,
kATSUToTextEnd,
0, 0,
byref(rect))
image_width = rect.right - rect.left + 2
image_height = rect.bottom - rect.top + 2
baseline = rect.bottom + 1
lsb = rect.left
# Resize Quartz context if necessary
if (image_width > self._bitmap_rect.size.width or
image_height > self._bitmap_rect.size.height):
self._create_bitmap_context(
int(max(image_width, self._bitmap_rect.size.width)),
int(max(image_height, self._bitmap_rect.size.height)))
set_layout_attributes(layout, {
kATSUCGContextTag: self._bitmap_context})
# Draw to the bitmap
carbon.CGContextClearRect(self._bitmap_context, self._bitmap_rect)
carbon.ATSUDrawText(layout,
0,
kATSUToTextEnd,
fixed(-lsb + 1), fixed(baseline))
advance = self._glyph_advance
# Round advance to nearest int. It actually looks good with sub-pixel
# advance as well -- Helvetica at 12pt is more tightly spaced, but
# Times New Roman at 12pt is too light. With integer positioning
# overall look seems darker and perhaps more uniform. It's also more
# similar (programmatically) to Win32 and FreeType. Still, worth
# messing around with (comment out next line) if you're interested.
advance = int(round(advance))
# Fix advance for zero-width space
if text == u'\u200b':
advance = 0
# A negative pitch is required, but it is much faster to load the
# glyph upside-down and flip the tex_coords. Note region used
# to start at top of glyph image.
pitch = int(4 * self._bitmap_rect.size.width)
image = pyglet.image.ImageData(image_width,
self._bitmap_rect.size.height, 'RGBA', self._bitmap, pitch)
skip_rows = int(self._bitmap_rect.size.height - image_height)
image = image.get_region(0, skip_rows, image.width, image_height)
glyph = self.font.create_glyph(image)
glyph.set_bearings(baseline, lsb - 1, int(advance))
t = list(glyph.tex_coords)
glyph.tex_coords = t[9:12] + t[6:9] + t[3:6] + t[:3]
return glyph
def _create_bitmap_context(self, width, height):
'''Create or recreate bitmap and Quartz context.'''
if self._bitmap_context:
carbon.CGContextRelease(self._bitmap_context)
components = 4
pitch = width * components
self._bitmap = (c_ubyte * (pitch * height))()
color_space = carbon.CGColorSpaceCreateDeviceRGB()
context = carbon.CGBitmapContextCreate(self._bitmap,
width, height, 8, pitch,
color_space, kCGImageAlphaPremultipliedLast)
carbon.CGColorSpaceRelease(color_space)
# Disable RGB decimated antialiasing, use standard
# antialiasing which won't break alpha.
carbon.CGContextSetShouldSmoothFonts(context, False)
carbon.CGContextSetShouldAntialias(context, True)
self._bitmap_context = context
self._bitmap_rect = CGRect()
self._bitmap_rect.origin.x = 0
self._bitmap_rect.origin.y = 0
self._bitmap_rect.size.width = width
self._bitmap_rect.size.height = height
class CarbonFont(base.Font):
glyph_renderer_class = CarbonGlyphRenderer
def __init__(self, name, size, bold=False, italic=False, dpi=None):
super(CarbonFont, self).__init__()
if not name:
name = 'Helvetica'
if dpi is None:
dpi = 96 # pyglet 1.1; in pyglet 1.0 this was 72.
# If application is not DPI-aware, DPI is fixed at 72. Scale
# font size to emulate other DPI. This will need to be fixed if issue
# #87 is implemented.
size = size * dpi / 72.
name = name.encode('ascii', 'ignore')
font_id = ATSUFontID()
carbon.ATSUFindFontFromName(
name,
len(name),
kFontFullName,
kFontNoPlatformCode,
kFontNoScriptCode,
kFontNoLanguageCode,
byref(font_id))
attributes = {
kATSUSizeTag: fixed(size),
kATSUFontTag: font_id,
kATSURGBAlphaColorTag: ATSURGBAlphaColor(1, 1, 1, 1),
kATSUQDBoldfaceTag: c_byte(bold),
kATSUQDItalicTag: c_byte(italic)
}
self.atsu_style = create_atsu_style(attributes)
self.calculate_metrics()
@classmethod
def have_font(cls, name):
font_id = ATSUFontID()
name = name.encode('ascii', 'ignore')
r = carbon.ATSUFindFontFromName(
name,
len(name),
kFontFullName,
kFontNoPlatformCode,
kFontNoScriptCode,
kFontNoLanguageCode,
byref(font_id))
return r != kATSUInvalidFontErr
def calculate_metrics(self):
# It seems the only way to get the font's ascent and descent is to lay
# out some glyphs and measure them.
# fake ucs2 string
text = '\0a'
layout = c_void_p()
carbon.ATSUCreateTextLayout(byref(layout))
carbon.ATSUSetTextPointerLocation(layout, text,
kATSUFromTextBeginning, kATSUToTextEnd, 1)
carbon.ATSUSetRunStyle(layout, self.atsu_style,
kATSUFromTextBeginning, kATSUToTextEnd)
# determine the metrics for this font only
carbon.ATSUSetTransientFontMatching(layout, False)
value = ATSUTextMeasurement()
carbon.ATSUGetLineControl(layout, 0, kATSULineAscentTag,
sizeof(value), byref(value), None)
self.ascent = int(math.ceil(fix2float(value)))
carbon.ATSUGetLineControl(layout, 0, kATSULineDescentTag,
sizeof(value), byref(value), None)
self.descent = -int(math.ceil(fix2float(value)))
@classmethod
def add_font_data(cls, data):
container = c_void_p()
r = carbon.ATSFontActivateFromMemory(data, len(data),
kATSFontContextLocal, kATSFontFormatUnspecified, None, 0,
byref(container))
_oscheck(r)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Load fonts and render text.
This is a fairly-low level interface to text rendering. Obtain a font using
`load`::
from pyglet import font
arial = font.load('Arial', 14, bold=True, italic=False)
pyglet will load any system-installed fonts. You can add additional fonts
(for example, from your program resources) using `add_file` or
`add_directory`.
Obtain a list of `Glyph` objects for a string of text using the `Font`
object::
text = 'Hello, world!'
glyphs = arial.get_glyphs(text)
The most efficient way to render these glyphs is with a `GlyphString`::
glyph_string = GlyphString(text, glyphs)
glyph_string.draw()
There are also a variety of methods in both `Font` and
`GlyphString` to facilitate word-wrapping.
A convenient way to render a string of text is with a `Text`::
text = Text(font, text)
text.draw()
See the `pyglet.font.base` module for documentation on the base classes used
by this package.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import sys
import os
import math
import weakref
import pyglet
from pyglet.gl import *
from pyglet import gl
from pyglet import image
from pyglet import window
class GlyphString(object):
'''An immutable string of glyphs that can be rendered quickly.
This class is ideal for quickly rendering single or multi-line strings
of text that use the same font. To wrap text using a glyph string,
call `get_break_index` to find the optimal breakpoint for each line,
the repeatedly call `draw` for each breakpoint.
:deprecated: Use `pyglet.text.layout` classes.
'''
def __init__(self, text, glyphs, x=0, y=0):
'''Create a glyph string.
The `text` string is used to determine valid breakpoints; all glyphs
must have already been determined using
`pyglet.font.base.Font.get_glyphs`. The string
will be positioned with the baseline of the left-most glyph at the
given coordinates.
:Parameters:
`text` : str or unicode
String to represent.
`glyphs` : list of `pyglet.font.base.Glyph`
Glyphs representing `text`.
`x` : float
X coordinate of the left-side bearing of the left-most glyph.
`y` : float
Y coordinate of the baseline.
'''
# Create an interleaved array in GL_T2F_V3F format and determine
# state changes required.
lst = []
texture = None
self.text = text
self.states = []
self.cumulative_advance = [] # for fast post-string breaking
state_from = 0
state_length = 0
for i, glyph in enumerate(glyphs):
if glyph.owner != texture:
if state_length:
self.states.append((state_from, state_length, texture))
texture = glyph.owner
state_from = i
state_length = 0
state_length += 1
t = glyph.tex_coords
lst += [t[0], t[1], t[2], 1.,
x + glyph.vertices[0], y + glyph.vertices[1], 0., 1.,
t[3], t[4], t[5], 1.,
x + glyph.vertices[2], y + glyph.vertices[1], 0., 1.,
t[6], t[7], t[8], 1.,
x + glyph.vertices[2], y + glyph.vertices[3], 0., 1.,
t[9], t[10], t[11], 1.,
x + glyph.vertices[0], y + glyph.vertices[3], 0., 1.]
x += glyph.advance
self.cumulative_advance.append(x)
self.states.append((state_from, state_length, texture))
self.array = (c_float * len(lst))(*lst)
self.width = x
def get_break_index(self, from_index, width):
'''Find a breakpoint within the text for a given width.
Returns a valid breakpoint after `from_index` so that the text
between `from_index` and the breakpoint fits within `width` pixels.
This method uses precomputed cumulative glyph widths to give quick
answer, and so is much faster than
`pyglet.font.base.Font.get_glyphs_for_width`.
:Parameters:
`from_index` : int
Index of text to begin at, or 0 for the beginning of the
string.
`width` : float
Maximum width to use.
:rtype: int
:return: the index of text which will be used as the breakpoint, or
`from_index` if there is no valid breakpoint.
'''
to_index = from_index
if from_index >= len(self.text):
return from_index
if from_index:
width += self.cumulative_advance[from_index-1]
for i, (c, w) in enumerate(
zip(self.text[from_index:],
self.cumulative_advance[from_index:])):
if c in u'\u0020\u200b':
to_index = i + from_index + 1
if c == '\n':
return i + from_index + 1
if w > width:
return to_index
return to_index
def get_subwidth(self, from_index, to_index):
'''Return the width of a slice of this string.
:Parameters:
`from_index` : int
The start index of the string to measure.
`to_index` : int
The end index (exclusive) of the string to measure.
:rtype: float
'''
if to_index <= from_index:
return 0
width = self.cumulative_advance[to_index-1]
if from_index:
width -= self.cumulative_advance[from_index-1]
return width
def draw(self, from_index=0, to_index=None):
'''Draw a region of the glyph string.
Assumes texture state is enabled. To enable the texture state::
from pyglet.gl import *
glEnable(GL_TEXTURE_2D)
:Parameters:
`from_index` : int
Start index of text to render.
`to_index` : int
End index (exclusive) of text to render.
'''
if from_index >= len(self.text) or \
from_index == to_index or \
not self.text:
return
# XXX Safe to assume all required textures will use same blend state I
# think. (otherwise move this into loop)
self.states[0][2].apply_blend_state()
if from_index:
glPushMatrix()
glTranslatef(-self.cumulative_advance[from_index-1], 0, 0)
if to_index is None:
to_index = len(self.text)
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT)
glInterleavedArrays(GL_T4F_V4F, 0, self.array)
for state_from, state_length, texture in self.states:
if state_from + state_length < from_index:
continue
state_from = max(state_from, from_index)
state_length = min(state_length, to_index - state_from)
if state_length <= 0:
break
glBindTexture(GL_TEXTURE_2D, texture.id)
glDrawArrays(GL_QUADS, state_from * 4, state_length * 4)
glPopClientAttrib()
if from_index:
glPopMatrix()
class _TextZGroup(pyglet.graphics.Group):
z = 0
def set_state(self):
glTranslatef(0, 0, self.z)
def unset_state(self):
glTranslatef(0, 0, -self.z)
class Text(object):
'''Simple displayable text.
This is a convenience class for rendering strings of text. It takes
care of caching the vertices so the text can be rendered every frame with
little performance penalty.
Text can be word-wrapped by specifying a `width` to wrap into. If the
width is not specified, it gives the width of the text as laid out.
:Ivariables:
`x` : int
X coordinate of the text
`y` : int
Y coordinate of the text
:deprecated: Use `pyglet.text.Label`.
'''
# Alignment constants
#: Align the left edge of the text to the given X coordinate.
LEFT = 'left'
#: Align the horizontal center of the text to the given X coordinate.
CENTER = 'center'
#: Align the right edge of the text to the given X coordinate.
RIGHT = 'right'
#: Align the bottom of the descender of the final line of text with the
#: given Y coordinate.
BOTTOM = 'bottom'
#: Align the baseline of the first line of text with the given Y
#: coordinate.
BASELINE = 'baseline'
#: Align the top of the ascender of the first line of text with the given
#: Y coordinate.
TOP = 'top'
# None: no multiline
# 'width': multiline, wrapped to width
# 'multiline': multiline, no wrap
_wrap = None
# Internal bookkeeping for wrap only.
_width = None
def __init__(self, font, text='', x=0, y=0, z=0, color=(1,1,1,1),
width=None, halign=LEFT, valign=BASELINE):
'''Create displayable text.
:Parameters:
`font` : `Font`
Font to render the text in.
`text` : str
Initial string to render.
`x` : float
X coordinate of the left edge of the text.
`y` : float
Y coordinate of the baseline of the text. If the text is
word-wrapped, this refers to the first line of text.
`z` : float
Z coordinate of the text plane.
`color` : 4-tuple of float
Color to render the text in. Alpha values can be specified
in the fourth component.
`width` : float
Width to limit the rendering to. Text will be word-wrapped
if necessary.
`halign` : str
Alignment of the text. See `Text.halign` for details.
`valign` : str
Controls positioning of the text based off the y coordinate.
One of BASELINE, BOTTOM, CENTER or TOP. Defaults to BASELINE.
'''
multiline = False
if width is not None:
self._width = width
self._wrap = 'width'
multiline = True
elif '\n' in text:
self._wrap = 'multiline'
multiline = True
self._group = _TextZGroup()
self._document = pyglet.text.decode_text(text)
self._layout = pyglet.text.layout.TextLayout(self._document,
width=width,
multiline=multiline,
wrap_lines=width is not None,
dpi=font.dpi,
group=self._group)
self._layout.begin_update()
if self._wrap == 'multiline':
self._document.set_style(0, len(text), dict(wrap=False))
self.font = font
self.color = color
self._x = x
self.y = y
self.z = z
self.width = width
self.halign = halign
self.valign = valign
self._update_layout_halign()
self._layout.end_update()
def _get_font(self):
return self._font
def _set_font(self, font):
self._font = font
self._layout.begin_update()
self._document.set_style(0, len(self._document.text), {
'font_name': font.name,
'font_size': font.size,
'bold': font.bold,
'italic': font.italic,
})
self._layout._dpi = font.dpi
self._layout.end_update()
font = property(_get_font, _set_font)
def _get_color(self):
color = self._document.get_style('color')
if color is None:
return (1., 1., 1., 1.)
return tuple([c/255. for c in color])
def _set_color(self, color):
color = [int(c * 255) for c in color]
self._document.set_style(0, len(self._document.text), {
'color': color,
})
color = property(_get_color, _set_color)
def _update_layout_halign(self):
if self._layout.multiline:
# TextLayout has a different interpretation of halign that doesn't
# consider the width to be a special factor; here we emulate the
# old behaviour by fudging the layout x value.
if self._layout.anchor_x == 'left':
self._layout.x = self.x
elif self._layout.anchor_x == 'center':
self._layout.x = self.x + self._layout.width - \
self._layout.content_width // 2
elif self._layout.anchor_x == 'right':
self._layout.x = self.x + 2 * self._layout.width - \
self._layout.content_width
else:
self._layout.x = self.x
def _get_x(self):
return self._x
def _set_x(self, x):
self._x = x
self._update_layout_halign()
x = property(_get_x, _set_x)
def _get_y(self):
return self._layout.y
def _set_y(self, y):
self._layout.y = y
y = property(_get_y, _set_y)
def _get_z(self):
return self._group.z
def _set_z(self, z):
self._group.z = z
z = property(_get_z, _set_z)
def _update_wrap(self):
if self._width is not None:
self._wrap = 'width'
elif '\n' in self.text:
self._wrap = 'multiline'
self._layout.begin_update()
if self._wrap == None:
self._layout.multiline = False
elif self._wrap == 'width':
self._layout.width = self._width
self._layout.multiline = True
self._document.set_style(0, len(self.text), dict(wrap=True))
elif self._wrap == 'multiline':
self._layout.multiline = True
self._document.set_style(0, len(self.text), dict(wrap=False))
self._update_layout_halign()
self._layout.end_update()
def _get_width(self):
if self._wrap == 'width':
return self._layout.width
else:
return self._layout.content_width
def _set_width(self, width):
self._width = width
self._layout._wrap_lines_flag = width is not None
self._update_wrap()
width = property(_get_width, _set_width,
doc='''Width of the text.
When set, this enables word-wrapping to the specified width.
Otherwise, the width of the text as it will be rendered can be
determined.
:type: float
''')
def _get_height(self):
return self._layout.content_height
height = property(_get_height,
doc='''Height of the text.
This property is the ascent minus the descent of the font, unless
there is more than one line of word-wrapped text, in which case
the height takes into account the line leading. Read-only.
:type: float
''')
def _get_text(self):
return self._document.text
def _set_text(self, text):
self._document.text = text
self._update_wrap()
text = property(_get_text, _set_text,
doc='''Text to render.
The glyph vertices are only recalculated as needed, so multiple
changes to the text can be performed with no performance penalty.
:type: str
''')
def _get_halign(self):
return self._layout.anchor_x
def _set_halign(self, halign):
self._layout.anchor_x = halign
self._update_layout_halign()
halign = property(_get_halign, _set_halign,
doc='''Horizontal alignment of the text.
The text is positioned relative to `x` and `width` according to this
property, which must be one of the alignment constants `LEFT`,
`CENTER` or `RIGHT`.
:type: str
''')
def _get_valign(self):
return self._layout.anchor_y
def _set_valign(self, valign):
self._layout.anchor_y = valign
valign = property(_get_valign, _set_valign,
doc='''Vertical alignment of the text.
The text is positioned relative to `y` according to this property,
which must be one of the alignment constants `BOTTOM`, `BASELINE`,
`CENTER` or `TOP`.
:type: str
''')
def _get_leading(self):
return self._document.get_style('leading') or 0
def _set_leading(self, leading):
self._document.set_style(0, len(self._document.text), {
'leading': leading,
})
leading = property(_get_leading, _set_leading,
doc='''Vertical space between adjacent lines, in pixels.
:type: int
''')
def _get_line_height(self):
return self._font.ascent - self._font.descent + self.leading
def _set_line_height(self, line_height):
self.leading = line_height - (self._font.ascent - self._font.descent)
line_height = property(_get_line_height, _set_line_height,
doc='''Vertical distance between adjacent baselines, in pixels.
:type: int
''')
def draw(self):
self._layout.draw()
if not getattr(sys, 'is_epydoc', False):
if pyglet.compat_platform == 'darwin':
if pyglet.options['darwin_cocoa']:
from pyglet.font.quartz import QuartzFont
_font_class = QuartzFont
else:
from pyglet.font.carbon import CarbonFont
_font_class = CarbonFont
elif pyglet.compat_platform in ('win32', 'cygwin'):
if pyglet.options['font'][0] == 'win32':
from pyglet.font.win32 import Win32Font
_font_class = Win32Font
elif pyglet.options['font'][0] == 'gdiplus':
from pyglet.font.win32 import GDIPlusFont
_font_class = GDIPlusFont
else:
assert False, 'Unknown font driver'
else:
from pyglet.font.freetype import FreeTypeFont
_font_class = FreeTypeFont
def have_font(name):
'''Check if specified system font name is available.'''
return _font_class.have_font(name)
def load(name=None, size=None, bold=False, italic=False, dpi=None):
'''Load a font for rendering.
:Parameters:
`name` : str, or list of str
Font family, for example, "Times New Roman". If a list of names
is provided, the first one matching a known font is used. If no
font can be matched to the name(s), a default font is used. In
pyglet 1.1, the name may be omitted.
`size` : float
Size of the font, in points. The returned font may be an exact
match or the closest available. In pyglet 1.1, the size may be
omitted, and defaults to 12pt.
`bold` : bool
If True, a bold variant is returned, if one exists for the given
family and size.
`italic` : bool
If True, an italic variant is returned, if one exists for the given
family and size.
`dpi` : float
The assumed resolution of the display device, for the purposes of
determining the pixel size of the font. Defaults to 96.
:rtype: `Font`
'''
# Arbitrary default size
if size is None:
size = 12
if dpi is None:
dpi = 96
# Find first matching name
if type(name) in (tuple, list):
for n in name:
if _font_class.have_font(n):
name = n
break
else:
name = None
# Locate or create font cache
shared_object_space = gl.current_context.object_space
if not hasattr(shared_object_space, 'pyglet_font_font_cache'):
shared_object_space.pyglet_font_font_cache = \
weakref.WeakValueDictionary()
shared_object_space.pyglet_font_font_hold = []
font_cache = shared_object_space.pyglet_font_font_cache
font_hold = shared_object_space.pyglet_font_font_hold
# Look for font name in font cache
descriptor = (name, size, bold, italic, dpi)
if descriptor in font_cache:
return font_cache[descriptor]
# Not in cache, create from scratch
font = _font_class(name, size, bold=bold, italic=italic, dpi=dpi)
# Save parameters for new-style layout classes to recover
font.name = name
font.size = size
font.bold = bold
font.italic = italic
font.dpi = dpi
# Cache font in weak-ref dictionary to avoid reloading while still in use
font_cache[descriptor] = font
# Hold onto refs of last three loaded fonts to prevent them being
# collected if momentarily dropped.
del font_hold[3:]
font_hold.insert(0, font)
return font
def add_file(font):
'''Add a font to pyglet's search path.
In order to load a font that is not installed on the system, you must
call this method to tell pyglet that it exists. You can supply
either a filename or any file-like object.
The font format is platform-dependent, but is typically a TrueType font
file containing a single font face. Note that to load this file after
adding it you must specify the face name to `load`, not the filename.
:Parameters:
`font` : str or file
Filename or file-like object to load fonts from.
'''
if type(font) in (str, unicode):
font = open(font, 'rb')
if hasattr(font, 'read'):
font = font.read()
_font_class.add_font_data(font)
def add_directory(dir):
'''Add a directory of fonts to pyglet's search path.
This function simply calls `add_file` for each file with a ``.ttf``
extension in the given directory. Subdirectories are not searched.
:Parameters:
`dir` : str
Directory that contains font files.
'''
for file in os.listdir(dir):
if file[-4:].lower() == '.ttf':
add_file(os.path.join(dir, file))
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
from ctypes import *
from warnings import warn
import pyglet.lib
from pyglet.font import base
from pyglet import image
from pyglet.font.freetype_lib import *
from pyglet.compat import asbytes
# fontconfig library definitions
fontconfig = pyglet.lib.load_library('fontconfig')
FcResult = c_int
fontconfig.FcPatternBuild.restype = c_void_p
fontconfig.FcPatternCreate.restype = c_void_p
fontconfig.FcFontMatch.restype = c_void_p
fontconfig.FcFreeTypeCharIndex.restype = c_uint
fontconfig.FcPatternAddDouble.argtypes = [c_void_p, c_char_p, c_double]
fontconfig.FcPatternAddInteger.argtypes = [c_void_p, c_char_p, c_int]
fontconfig.FcPatternAddString.argtypes = [c_void_p, c_char_p, c_char_p]
fontconfig.FcConfigSubstitute.argtypes = [c_void_p, c_void_p, c_int]
fontconfig.FcDefaultSubstitute.argtypes = [c_void_p]
fontconfig.FcFontMatch.argtypes = [c_void_p, c_void_p, c_void_p]
fontconfig.FcPatternDestroy.argtypes = [c_void_p]
fontconfig.FcPatternGetFTFace.argtypes = [c_void_p, c_char_p, c_int, c_void_p]
fontconfig.FcPatternGet.argtypes = [c_void_p, c_char_p, c_int, c_void_p]
FC_FAMILY = asbytes('family')
FC_SIZE = asbytes('size')
FC_SLANT = asbytes('slant')
FC_WEIGHT = asbytes('weight')
FC_FT_FACE = asbytes('ftface')
FC_FILE = asbytes('file')
FC_WEIGHT_REGULAR = 80
FC_WEIGHT_BOLD = 200
FC_SLANT_ROMAN = 0
FC_SLANT_ITALIC = 100
FT_STYLE_FLAG_ITALIC = 1
FT_STYLE_FLAG_BOLD = 2
(FT_RENDER_MODE_NORMAL,
FT_RENDER_MODE_LIGHT,
FT_RENDER_MODE_MONO,
FT_RENDER_MODE_LCD,
FT_RENDER_MODE_LCD_V) = range(5)
def FT_LOAD_TARGET_(x):
return (x & 15) << 16
FT_LOAD_TARGET_NORMAL = FT_LOAD_TARGET_(FT_RENDER_MODE_NORMAL)
FT_LOAD_TARGET_LIGHT = FT_LOAD_TARGET_(FT_RENDER_MODE_LIGHT)
FT_LOAD_TARGET_MONO = FT_LOAD_TARGET_(FT_RENDER_MODE_MONO)
FT_LOAD_TARGET_LCD = FT_LOAD_TARGET_(FT_RENDER_MODE_LCD)
FT_LOAD_TARGET_LCD_V = FT_LOAD_TARGET_(FT_RENDER_MODE_LCD_V)
(FT_PIXEL_MODE_NONE,
FT_PIXEL_MODE_MONO,
FT_PIXEL_MODE_GRAY,
FT_PIXEL_MODE_GRAY2,
FT_PIXEL_MODE_GRAY4,
FT_PIXEL_MODE_LCD,
FT_PIXEL_MODE_LCD_V) = range(7)
(FcTypeVoid,
FcTypeInteger,
FcTypeDouble,
FcTypeString,
FcTypeBool,
FcTypeMatrix,
FcTypeCharSet,
FcTypeFTFace,
FcTypeLangSet) = range(9)
FcType = c_int
(FcMatchPattern,
FcMatchFont) = range(2)
FcMatchKind = c_int
class _FcValueUnion(Union):
_fields_ = [
('s', c_char_p),
('i', c_int),
('b', c_int),
('d', c_double),
('m', c_void_p),
('c', c_void_p),
('f', c_void_p),
('p', c_void_p),
('l', c_void_p),
]
class FcValue(Structure):
_fields_ = [
('type', FcType),
('u', _FcValueUnion)
]
# End of library definitions
def f16p16_to_float(value):
return float(value) / (1 << 16)
def float_to_f16p16(value):
return int(value * (1 << 16))
def f26p6_to_float(value):
return float(value) / (1 << 6)
def float_to_f26p6(value):
return int(value * (1 << 6))
class FreeTypeGlyphRenderer(base.GlyphRenderer):
def __init__(self, font):
super(FreeTypeGlyphRenderer, self).__init__(font)
self.font = font
def render(self, text):
face = self.font.face
FT_Set_Char_Size(face, 0, self.font._face_size,
self.font._dpi, self.font._dpi)
glyph_index = fontconfig.FcFreeTypeCharIndex(byref(face), ord(text[0]))
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER)
if error != 0:
raise base.FontException(
'Could not load glyph for "%c"' % text[0], error)
glyph_slot = face.glyph.contents
width = glyph_slot.bitmap.width
height = glyph_slot.bitmap.rows
baseline = height - glyph_slot.bitmap_top
lsb = glyph_slot.bitmap_left
advance = int(f26p6_to_float(glyph_slot.advance.x))
mode = glyph_slot.bitmap.pixel_mode
pitch = glyph_slot.bitmap.pitch
if mode == FT_PIXEL_MODE_MONO:
# BCF fonts always render to 1 bit mono, regardless of render
# flags. (freetype 2.3.5)
bitmap_data = cast(glyph_slot.bitmap.buffer,
POINTER(c_ubyte * (pitch * height))).contents
data = (c_ubyte * (pitch * 8 * height))()
data_i = 0
for byte in bitmap_data:
# Data is MSB; left-most pixel in a byte has value 128.
data[data_i + 0] = (byte & 0x80) and 255 or 0
data[data_i + 1] = (byte & 0x40) and 255 or 0
data[data_i + 2] = (byte & 0x20) and 255 or 0
data[data_i + 3] = (byte & 0x10) and 255 or 0
data[data_i + 4] = (byte & 0x08) and 255 or 0
data[data_i + 5] = (byte & 0x04) and 255 or 0
data[data_i + 6] = (byte & 0x02) and 255 or 0
data[data_i + 7] = (byte & 0x01) and 255 or 0
data_i += 8
pitch <<= 3
elif mode == FT_PIXEL_MODE_GRAY:
# Usual case
data = glyph_slot.bitmap.buffer
else:
raise base.FontException('Unsupported render mode for this glyph')
# pitch should be negative, but much faster to just swap tex_coords
img = image.ImageData(width, height, 'A', data, pitch)
glyph = self.font.create_glyph(img)
glyph.set_bearings(baseline, lsb, advance)
t = list(glyph.tex_coords)
glyph.tex_coords = t[9:12] + t[6:9] + t[3:6] + t[:3]
return glyph
class FreeTypeMemoryFont(object):
def __init__(self, data):
self.buffer = (ctypes.c_byte * len(data))()
ctypes.memmove(self.buffer, data, len(data))
ft_library = ft_get_library()
self.face = FT_Face()
r = FT_New_Memory_Face(ft_library,
self.buffer, len(self.buffer), 0, self.face)
if r != 0:
raise base.FontException('Could not load font data')
self.name = self.face.contents.family_name
self.bold = self.face.contents.style_flags & FT_STYLE_FLAG_BOLD != 0
self.italic = self.face.contents.style_flags & FT_STYLE_FLAG_ITALIC != 0
# Replace Freetype's generic family name with TTF/OpenType specific
# name if we can find one; there are some instances where Freetype
# gets it wrong.
if self.face.contents.face_flags & FT_FACE_FLAG_SFNT:
name = FT_SfntName()
for i in range(FT_Get_Sfnt_Name_Count(self.face)):
result = FT_Get_Sfnt_Name(self.face, i, name)
if result != 0:
continue
if not (name.platform_id == TT_PLATFORM_MICROSOFT and
name.encoding_id == TT_MS_ID_UNICODE_CS):
continue
if name.name_id == TT_NAME_ID_FONT_FAMILY:
string = string_at(name.string, name.string_len)
self.name = string.decode('utf-16be', 'ignore')
def __del__(self):
try:
FT_Done_Face(self.face)
except:
pass
class FreeTypeFont(base.Font):
glyph_renderer_class = FreeTypeGlyphRenderer
# Map font (name, bold, italic) to FreeTypeMemoryFont
_memory_fonts = {}
def __init__(self, name, size, bold=False, italic=False, dpi=None):
super(FreeTypeFont, self).__init__()
if dpi is None:
dpi = 96 # as of pyglet 1.1; pyglet 1.0 had 72.
# Check if font name/style matches a font loaded into memory by user
lname = name and name.lower() or ''
if (lname, bold, italic) in self._memory_fonts:
font = self._memory_fonts[lname, bold, italic]
self._set_face(font.face, size, dpi)
return
# Use fontconfig to match the font (or substitute a default).
ft_library = ft_get_library()
match = self.get_fontconfig_match(name, size, bold, italic)
if not match:
raise base.FontException('Could not match font "%s"' % name)
f = FT_Face()
if fontconfig.FcPatternGetFTFace(match, FC_FT_FACE, 0, byref(f)) != 0:
value = FcValue()
result = fontconfig.FcPatternGet(match, FC_FILE, 0, byref(value))
if result != 0:
raise base.FontException('No filename or FT face for "%s"' % \
name)
result = FT_New_Face(ft_library, value.u.s, 0, byref(f))
if result:
raise base.FontException('Could not load "%s": %d' % \
(name, result))
fontconfig.FcPatternDestroy(match)
self._set_face(f, size, dpi)
def _set_face(self, face, size, dpi):
self.face = face.contents
self._face_size = float_to_f26p6(size)
self._dpi = dpi
FT_Set_Char_Size(self.face, 0, float_to_f26p6(size), dpi, dpi)
metrics = self.face.size.contents.metrics
if metrics.ascender == 0 and metrics.descender == 0:
# Workaround broken fonts with no metrics. Has been observed with
# courR12-ISO8859-1.pcf.gz: "Courier" "Regular"
#
# None of the metrics fields are filled in, so render a glyph and
# grab its height as the ascent, and make up an arbitrary
# descent.
i = fontconfig.FcFreeTypeCharIndex(byref(self.face), ord('X'))
FT_Load_Glyph(self.face, i, FT_LOAD_RENDER)
self.ascent = self.face.available_sizes.contents.height
self.descent = -self.ascent // 4 # arbitrary.
else:
self.ascent = int(f26p6_to_float(metrics.ascender))
self.descent = int(f26p6_to_float(metrics.descender))
@staticmethod
def get_fontconfig_match(name, size, bold, italic):
if bold:
bold = FC_WEIGHT_BOLD
else:
bold = FC_WEIGHT_REGULAR
if italic:
italic = FC_SLANT_ITALIC
else:
italic = FC_SLANT_ROMAN
fontconfig.FcInit()
if isinstance(name, unicode):
name = name.encode('utf8')
pattern = fontconfig.FcPatternCreate()
fontconfig.FcPatternAddDouble(pattern, FC_SIZE, c_double(size))
fontconfig.FcPatternAddInteger(pattern, FC_WEIGHT, bold)
fontconfig.FcPatternAddInteger(pattern, FC_SLANT, italic)
fontconfig.FcPatternAddString(pattern, FC_FAMILY, name)
fontconfig.FcConfigSubstitute(0, pattern, FcMatchPattern)
fontconfig.FcDefaultSubstitute(pattern)
# Look for a font that matches pattern
result = FcResult()
match = fontconfig.FcFontMatch(0, pattern, byref(result))
fontconfig.FcPatternDestroy(pattern)
return match
@classmethod
def have_font(cls, name):
value = FcValue()
match = cls.get_fontconfig_match(name, 12, False, False)
#result = fontconfig.FcPatternGet(match, FC_FAMILY, 0, byref(value))
if value.u.s == name:
return True
else:
name = name.lower()
for font in cls._memory_fonts.values():
if font.name.lower() == name:
return True
return False
@classmethod
def add_font_data(cls, data):
font = FreeTypeMemoryFont(data)
cls._memory_fonts[font.name.lower(), font.bold, font.italic] = font
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from ctypes import *
from pyglet.canvas.xlib import XlibCanvas
from base import Config, CanvasConfig, Context
from pyglet import gl
from pyglet.gl import glx
from pyglet.gl import glxext_arb
from pyglet.gl import glx_info
from pyglet.gl import glxext_mesa
class XlibConfig(Config):
def match(self, canvas):
if not isinstance(canvas, XlibCanvas):
raise RuntimeError('Canvas must be instance of XlibCanvas')
x_display = canvas.display._display
x_screen = canvas.display.x_screen
info = glx_info.GLXInfo(x_display)
have_13 = info.have_version(1, 3)
if have_13:
config_class = XlibCanvasConfig13
else:
if 'ATI' in info.get_client_vendor():
config_class = XlibCanvasConfig10ATI
else:
config_class = XlibCanvasConfig10
# Construct array of attributes
attrs = []
for name, value in self.get_gl_attributes():
attr = config_class.attribute_ids.get(name, None)
if attr and value is not None:
attrs.extend([attr, int(value)])
if have_13:
attrs.extend([glx.GLX_X_RENDERABLE, True])
else:
attrs.extend([glx.GLX_RGBA, True])
if len(attrs):
attrs.extend([0, 0])
attrib_list = (c_int * len(attrs))(*attrs)
else:
attrib_list = None
if have_13:
elements = c_int()
configs = glx.glXChooseFBConfig(x_display, x_screen,
attrib_list, byref(elements))
if not configs:
return []
configs = cast(configs,
POINTER(glx.GLXFBConfig * elements.value)).contents
result = [config_class(canvas, info, c, self) for c in configs]
# Can't free array until all XlibGLConfig13's are GC'd. Too much
# hassle, live with leak. XXX
#xlib.XFree(configs)
return result
else:
try:
return [config_class(canvas, info, attrib_list, self)]
except gl.ContextException:
return []
class BaseXlibCanvasConfig(CanvasConfig):
# Common code shared between GLX 1.0 and GLX 1.3 configs.
attribute_ids = {
'buffer_size': glx.GLX_BUFFER_SIZE,
'level': glx.GLX_LEVEL, # Not supported
'double_buffer': glx.GLX_DOUBLEBUFFER,
'stereo': glx.GLX_STEREO,
'aux_buffers': glx.GLX_AUX_BUFFERS,
'red_size': glx.GLX_RED_SIZE,
'green_size': glx.GLX_GREEN_SIZE,
'blue_size': glx.GLX_BLUE_SIZE,
'alpha_size': glx.GLX_ALPHA_SIZE,
'depth_size': glx.GLX_DEPTH_SIZE,
'stencil_size': glx.GLX_STENCIL_SIZE,
'accum_red_size': glx.GLX_ACCUM_RED_SIZE,
'accum_green_size': glx.GLX_ACCUM_GREEN_SIZE,
'accum_blue_size': glx.GLX_ACCUM_BLUE_SIZE,
'accum_alpha_size': glx.GLX_ACCUM_ALPHA_SIZE,
}
def __init__(self, canvas, glx_info, config):
super(BaseXlibCanvasConfig, self).__init__(canvas, config)
self.glx_info = glx_info
def compatible(self, canvas):
# TODO check more
return isinstance(canvas, XlibCanvas)
def _create_glx_context(self, share):
raise NotImplementedError('abstract')
def is_complete(self):
return True
def get_visual_info(self):
raise NotImplementedError('abstract')
class XlibCanvasConfig10(BaseXlibCanvasConfig):
def __init__(self, canvas, glx_info, attrib_list, config):
super(XlibCanvasConfig10, self).__init__(canvas, glx_info, config)
x_display = canvas.display._display
x_screen = canvas.display.x_screen
self._visual_info = glx.glXChooseVisual(
x_display, x_screen, attrib_list)
if not self._visual_info:
raise gl.ContextException('No conforming visual exists')
for name, attr in self.attribute_ids.items():
value = c_int()
result = glx.glXGetConfig(
x_display, self._visual_info, attr, byref(value))
if result >= 0:
setattr(self, name, value.value)
self.sample_buffers = 0
self.samples = 0
def get_visual_info(self):
return self._visual_info.contents
def create_context(self, share):
return XlibContext10(self, share)
class XlibCanvasConfig10ATI(XlibCanvasConfig10):
attribute_ids = BaseXlibCanvasConfig.attribute_ids.copy()
del attribute_ids['stereo']
stereo = False
class XlibCanvasConfig13(BaseXlibCanvasConfig):
attribute_ids = BaseXlibCanvasConfig.attribute_ids.copy()
attribute_ids.update({
'sample_buffers': glx.GLX_SAMPLE_BUFFERS,
'samples': glx.GLX_SAMPLES,
# Not supported in current pyglet API:
'render_type': glx.GLX_RENDER_TYPE,
'config_caveat': glx.GLX_CONFIG_CAVEAT,
'transparent_type': glx.GLX_TRANSPARENT_TYPE,
'transparent_index_value': glx.GLX_TRANSPARENT_INDEX_VALUE,
'transparent_red_value': glx.GLX_TRANSPARENT_RED_VALUE,
'transparent_green_value': glx.GLX_TRANSPARENT_GREEN_VALUE,
'transparent_blue_value': glx.GLX_TRANSPARENT_BLUE_VALUE,
'transparent_alpha_value': glx.GLX_TRANSPARENT_ALPHA_VALUE,
# Used internally
'x_renderable': glx.GLX_X_RENDERABLE,
})
def __init__(self, canvas, glx_info, fbconfig, config):
super(XlibCanvasConfig13, self).__init__(canvas, glx_info, config)
x_display = canvas.display._display
self._fbconfig = fbconfig
for name, attr in self.attribute_ids.items():
value = c_int()
result = glx.glXGetFBConfigAttrib(
x_display, self._fbconfig, attr, byref(value))
if result >= 0:
setattr(self, name, value.value)
def get_visual_info(self):
return glx.glXGetVisualFromFBConfig(
self.canvas.display._display, self._fbconfig).contents
def create_context(self, share):
if self.glx_info.have_extension('GLX_ARB_create_context'):
return XlibContextARB(self, share)
else:
return XlibContext13(self, share)
class BaseXlibContext(Context):
def __init__(self, config, share):
super(BaseXlibContext, self).__init__(config, share)
self.x_display = config.canvas.display._display
self.glx_context = self._create_glx_context(share)
glx_context_id = self.glx_context.contents._opaque_struct
if glx_context_id == glx.GLX_BAD_CONTEXT:
raise gl.ContextException('Invalid context share')
elif glx_context_id == glx.GLXBadFBConfig:
raise gl.ContextException('Invalid GL configuration')
elif glx_context_id < 0:
raise gl.ContextException('Could not create GL context')
self._have_SGI_video_sync = \
config.glx_info.have_extension('GLX_SGI_video_sync')
self._have_SGI_swap_control = \
config.glx_info.have_extension('GLX_SGI_swap_control')
self._have_MESA_swap_control = \
config.glx_info.have_extension('GLX_MESA_swap_control')
# In order of preference:
# 1. GLX_MESA_swap_control (more likely to work where video_sync will
# not)
# 2. GLX_SGI_video_sync (does not work on Intel 945GM, but that has
# MESA)
# 3. GLX_SGI_swap_control (cannot be disabled once enabled).
self._use_video_sync = (self._have_SGI_video_sync and
not self._have_MESA_swap_control)
# XXX mandate that vsync defaults on across all platforms.
self._vsync = True
def is_direct(self):
return glx.glXIsDirect(self.x_display, self.glx_context)
def set_vsync(self, vsync=True):
self._vsync = vsync
if not self._use_video_sync:
interval = vsync and 1 or 0
if self._have_MESA_swap_control:
glxext_mesa.glXSwapIntervalMESA(interval)
elif self._have_SGI_swap_control and interval:
# SGI_swap_control interval cannot be set to 0
glxext_arb.glXSwapIntervalSGI(interval)
def get_vsync(self):
return self._vsync
def _wait_vsync(self):
if self._vsync and self._have_SGI_video_sync and self._use_video_sync:
count = c_uint()
glxext_arb.glXGetVideoSyncSGI(byref(count))
glxext_arb.glXWaitVideoSyncSGI(
2, (count.value + 1) % 2, byref(count))
class XlibContext10(BaseXlibContext):
def __init__(self, config, share):
super(XlibContext10, self).__init__(config, share)
def _create_glx_context(self, share):
if self.config._requires_gl_3():
raise gl.ContextException(
'Require GLX_ARB_create_context extension to create ' +
'OpenGL 3 contexts.')
if share:
share_context = share.glx_context
else:
share_context = None
return glx.glXCreateContext(self.config.canvas.display._display,
self.config._visual_info, share_context, True)
def attach(self, canvas):
super(XlibContext10, self).attach(canvas)
self.set_current()
def set_current(self):
glx.glXMakeCurrent(self.x_display, self.canvas.x_window,
self.glx_context)
super(XlibContext10, self).set_current()
def detach(self):
if not self.canvas:
return
self.set_current()
gl.glFlush()
glx.glXMakeCurrent(self.x_display, 0, None)
super(XlibContext10, self).detach()
def destroy(self):
super(XlibContext10, self).destroy()
glx.glXDestroyContext(self.x_display, self.glx_context)
self.glx_context = None
def flip(self):
if not self.canvas:
return
if self._vsync:
self._wait_vsync()
glx.glXSwapBuffers(self.x_display, self.canvas.x_window)
class XlibContext13(BaseXlibContext):
def __init__(self, config, share):
super(XlibContext13, self).__init__(config, share)
self.glx_window = None
def _create_glx_context(self, share):
if self.config._requires_gl_3():
raise gl.ContextException(
'Require GLX_ARB_create_context extension to create ' +
'OpenGL 3 contexts.')
if share:
share_context = share.glx_context
else:
share_context = None
return glx.glXCreateNewContext(self.config.canvas.display._display,
self.config._fbconfig, glx.GLX_RGBA_TYPE, share_context, True)
def attach(self, canvas):
if canvas is self.canvas: # XXX do this for carbon too?
return
super(XlibContext13, self).attach(canvas)
self.glx_window = glx.glXCreateWindow(
self.x_display, self.config._fbconfig, canvas.x_window, None)
self.set_current()
def set_current(self):
glx.glXMakeContextCurrent(
self.x_display, self.glx_window, self.glx_window, self.glx_context)
super(XlibContext13, self).set_current()
def detach(self):
if not self.canvas:
return
self.set_current()
gl.glFlush() # needs to be in try/except?
super(XlibContext13, self).detach()
glx.glXMakeContextCurrent(self.x_display, 0, 0, None)
if self.glx_window:
glx.glXDestroyWindow(self.x_display, self.glx_window)
self.glx_window = None
def destroy(self):
super(XlibContext13, self).destroy()
if self.glx_window:
glx.glXDestroyWindow(self.config.display._display, self.glx_window)
self.glx_window = None
if self.glx_context:
glx.glXDestroyContext(self.x_display, self.glx_context)
self.glx_context = None
def flip(self):
if not self.glx_window:
return
if self._vsync:
self._wait_vsync()
glx.glXSwapBuffers(self.x_display, self.glx_window)
class XlibContextARB(XlibContext13):
def _create_glx_context(self, share):
if share:
share_context = share.glx_context
else:
share_context = None
attribs = []
if self.config.major_version is not None:
attribs.extend([glxext_arb.GLX_CONTEXT_MAJOR_VERSION_ARB,
self.config.major_version])
if self.config.minor_version is not None:
attribs.extend([glxext_arb.GLX_CONTEXT_MINOR_VERSION_ARB,
self.config.minor_version])
flags = 0
if self.config.forward_compatible:
flags |= glxext_arb.GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
if self.config.debug:
flags |= glxext_arb.GLX_CONTEXT_DEBUG_BIT_ARB
if flags:
attribs.extend([glxext_arb.GLX_CONTEXT_FLAGS_ARB, flags])
attribs.append(0)
attribs = (c_int * len(attribs))(*attribs)
return glxext_arb.glXCreateContextAttribsARB(
self.config.canvas.display._display,
self.config._fbconfig, share_context, True, attribs)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
import pyglet
__all__ = ['link_GL', 'link_GLU', 'link_AGL', 'link_GLX', 'link_WGL']
_debug_gl = pyglet.options['debug_gl']
_debug_gl_trace = pyglet.options['debug_gl_trace']
_debug_gl_trace_args = pyglet.options['debug_gl_trace_args']
class MissingFunctionException(Exception):
def __init__(self, name, requires=None, suggestions=None):
msg = '%s is not exported by the available OpenGL driver.' % name
if requires:
msg += ' %s is required for this functionality.' % requires
if suggestions:
msg += ' Consider alternative(s) %s.' % ', '.join(suggestions)
Exception.__init__(self, msg)
def missing_function(name, requires=None, suggestions=None):
def MissingFunction(*args, **kwargs):
raise MissingFunctionException(name, requires, suggestions)
return MissingFunction
_int_types = (ctypes.c_int16, ctypes.c_int32)
if hasattr(ctypes, 'c_int64'):
# Some builds of ctypes apparently do not have c_int64
# defined; it's a pretty good bet that these builds do not
# have 64-bit pointers.
_int_types += (ctypes.c_int64,)
for t in _int_types:
if ctypes.sizeof(t) == ctypes.sizeof(ctypes.c_size_t):
c_ptrdiff_t = t
class c_void(ctypes.Structure):
# c_void_p is a buggy return type, converting to int, so
# POINTER(None) == c_void_p is actually written as
# POINTER(c_void), so it can be treated as a real pointer.
_fields_ = [('dummy', ctypes.c_int)]
class GLException(Exception):
pass
def errcheck(result, func, arguments):
if _debug_gl_trace:
try:
name = func.__name__
except AttributeError:
name = repr(func)
if _debug_gl_trace_args:
trace_args = ', '.join([repr(arg)[:20] for arg in arguments])
print '%s(%s)' % (name, trace_args)
else:
print name
from pyglet import gl
context = gl.current_context
if not context:
raise GLException('No GL context; create a Window first')
if not context._gl_begin:
error = gl.glGetError()
if error:
msg = ctypes.cast(gl.gluErrorString(error), ctypes.c_char_p).value
raise GLException(msg)
return result
def errcheck_glbegin(result, func, arguments):
from pyglet import gl
context = gl.current_context
if not context:
raise GLException('No GL context; create a Window first')
context._gl_begin = True
return result
def errcheck_glend(result, func, arguments):
from pyglet import gl
context = gl.current_context
if not context:
raise GLException('No GL context; create a Window first')
context._gl_begin = False
return errcheck(result, func, arguments)
def decorate_function(func, name):
if _debug_gl:
if name == 'glBegin':
func.errcheck = errcheck_glbegin
elif name == 'glEnd':
func.errcheck = errcheck_glend
elif name not in ('glGetError', 'gluErrorString') and \
name[:3] not in ('glX', 'agl', 'wgl'):
func.errcheck = errcheck
link_AGL = None
link_GLX = None
link_WGL = None
if pyglet.compat_platform in ('win32', 'cygwin'):
from pyglet.gl.lib_wgl import link_GL, link_GLU, link_WGL
elif pyglet.compat_platform == 'darwin':
from pyglet.gl.lib_agl import link_GL, link_GLU, link_AGL
else:
from pyglet.gl.lib_glx import link_GL, link_GLU, link_GLX
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for /usr/include/GL/gl.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GL as _link_function
from pyglet.gl.lib import c_ptrdiff_t
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by gengl.py.
# Wrapper for /usr/include/GL/gl.h
GL_VERSION_1_1 = 1 # /usr/include/GL/gl.h:140
GL_VERSION_1_2 = 1 # /usr/include/GL/gl.h:141
GL_VERSION_1_3 = 1 # /usr/include/GL/gl.h:142
GL_ARB_imaging = 1 # /usr/include/GL/gl.h:143
GLenum = c_uint # /usr/include/GL/gl.h:149
GLboolean = c_ubyte # /usr/include/GL/gl.h:150
GLbitfield = c_uint # /usr/include/GL/gl.h:151
GLvoid = None # /usr/include/GL/gl.h:152
GLbyte = c_char # /usr/include/GL/gl.h:153
GLshort = c_short # /usr/include/GL/gl.h:154
GLint = c_int # /usr/include/GL/gl.h:155
GLubyte = c_ubyte # /usr/include/GL/gl.h:156
GLushort = c_ushort # /usr/include/GL/gl.h:157
GLuint = c_uint # /usr/include/GL/gl.h:158
GLsizei = c_int # /usr/include/GL/gl.h:159
GLfloat = c_float # /usr/include/GL/gl.h:160
GLclampf = c_float # /usr/include/GL/gl.h:161
GLdouble = c_double # /usr/include/GL/gl.h:162
GLclampd = c_double # /usr/include/GL/gl.h:163
GL_FALSE = 0 # /usr/include/GL/gl.h:172
GL_TRUE = 1 # /usr/include/GL/gl.h:173
GL_BYTE = 5120 # /usr/include/GL/gl.h:176
GL_UNSIGNED_BYTE = 5121 # /usr/include/GL/gl.h:177
GL_SHORT = 5122 # /usr/include/GL/gl.h:178
GL_UNSIGNED_SHORT = 5123 # /usr/include/GL/gl.h:179
GL_INT = 5124 # /usr/include/GL/gl.h:180
GL_UNSIGNED_INT = 5125 # /usr/include/GL/gl.h:181
GL_FLOAT = 5126 # /usr/include/GL/gl.h:182
GL_2_BYTES = 5127 # /usr/include/GL/gl.h:183
GL_3_BYTES = 5128 # /usr/include/GL/gl.h:184
GL_4_BYTES = 5129 # /usr/include/GL/gl.h:185
GL_DOUBLE = 5130 # /usr/include/GL/gl.h:186
GL_POINTS = 0 # /usr/include/GL/gl.h:189
GL_LINES = 1 # /usr/include/GL/gl.h:190
GL_LINE_LOOP = 2 # /usr/include/GL/gl.h:191
GL_LINE_STRIP = 3 # /usr/include/GL/gl.h:192
GL_TRIANGLES = 4 # /usr/include/GL/gl.h:193
GL_TRIANGLE_STRIP = 5 # /usr/include/GL/gl.h:194
GL_TRIANGLE_FAN = 6 # /usr/include/GL/gl.h:195
GL_QUADS = 7 # /usr/include/GL/gl.h:196
GL_QUAD_STRIP = 8 # /usr/include/GL/gl.h:197
GL_POLYGON = 9 # /usr/include/GL/gl.h:198
GL_VERTEX_ARRAY = 32884 # /usr/include/GL/gl.h:201
GL_NORMAL_ARRAY = 32885 # /usr/include/GL/gl.h:202
GL_COLOR_ARRAY = 32886 # /usr/include/GL/gl.h:203
GL_INDEX_ARRAY = 32887 # /usr/include/GL/gl.h:204
GL_TEXTURE_COORD_ARRAY = 32888 # /usr/include/GL/gl.h:205
GL_EDGE_FLAG_ARRAY = 32889 # /usr/include/GL/gl.h:206
GL_VERTEX_ARRAY_SIZE = 32890 # /usr/include/GL/gl.h:207
GL_VERTEX_ARRAY_TYPE = 32891 # /usr/include/GL/gl.h:208
GL_VERTEX_ARRAY_STRIDE = 32892 # /usr/include/GL/gl.h:209
GL_NORMAL_ARRAY_TYPE = 32894 # /usr/include/GL/gl.h:210
GL_NORMAL_ARRAY_STRIDE = 32895 # /usr/include/GL/gl.h:211
GL_COLOR_ARRAY_SIZE = 32897 # /usr/include/GL/gl.h:212
GL_COLOR_ARRAY_TYPE = 32898 # /usr/include/GL/gl.h:213
GL_COLOR_ARRAY_STRIDE = 32899 # /usr/include/GL/gl.h:214
GL_INDEX_ARRAY_TYPE = 32901 # /usr/include/GL/gl.h:215
GL_INDEX_ARRAY_STRIDE = 32902 # /usr/include/GL/gl.h:216
GL_TEXTURE_COORD_ARRAY_SIZE = 32904 # /usr/include/GL/gl.h:217
GL_TEXTURE_COORD_ARRAY_TYPE = 32905 # /usr/include/GL/gl.h:218
GL_TEXTURE_COORD_ARRAY_STRIDE = 32906 # /usr/include/GL/gl.h:219
GL_EDGE_FLAG_ARRAY_STRIDE = 32908 # /usr/include/GL/gl.h:220
GL_VERTEX_ARRAY_POINTER = 32910 # /usr/include/GL/gl.h:221
GL_NORMAL_ARRAY_POINTER = 32911 # /usr/include/GL/gl.h:222
GL_COLOR_ARRAY_POINTER = 32912 # /usr/include/GL/gl.h:223
GL_INDEX_ARRAY_POINTER = 32913 # /usr/include/GL/gl.h:224
GL_TEXTURE_COORD_ARRAY_POINTER = 32914 # /usr/include/GL/gl.h:225
GL_EDGE_FLAG_ARRAY_POINTER = 32915 # /usr/include/GL/gl.h:226
GL_V2F = 10784 # /usr/include/GL/gl.h:227
GL_V3F = 10785 # /usr/include/GL/gl.h:228
GL_C4UB_V2F = 10786 # /usr/include/GL/gl.h:229
GL_C4UB_V3F = 10787 # /usr/include/GL/gl.h:230
GL_C3F_V3F = 10788 # /usr/include/GL/gl.h:231
GL_N3F_V3F = 10789 # /usr/include/GL/gl.h:232
GL_C4F_N3F_V3F = 10790 # /usr/include/GL/gl.h:233
GL_T2F_V3F = 10791 # /usr/include/GL/gl.h:234
GL_T4F_V4F = 10792 # /usr/include/GL/gl.h:235
GL_T2F_C4UB_V3F = 10793 # /usr/include/GL/gl.h:236
GL_T2F_C3F_V3F = 10794 # /usr/include/GL/gl.h:237
GL_T2F_N3F_V3F = 10795 # /usr/include/GL/gl.h:238
GL_T2F_C4F_N3F_V3F = 10796 # /usr/include/GL/gl.h:239
GL_T4F_C4F_N3F_V4F = 10797 # /usr/include/GL/gl.h:240
GL_MATRIX_MODE = 2976 # /usr/include/GL/gl.h:243
GL_MODELVIEW = 5888 # /usr/include/GL/gl.h:244
GL_PROJECTION = 5889 # /usr/include/GL/gl.h:245
GL_TEXTURE = 5890 # /usr/include/GL/gl.h:246
GL_POINT_SMOOTH = 2832 # /usr/include/GL/gl.h:249
GL_POINT_SIZE = 2833 # /usr/include/GL/gl.h:250
GL_POINT_SIZE_GRANULARITY = 2835 # /usr/include/GL/gl.h:251
GL_POINT_SIZE_RANGE = 2834 # /usr/include/GL/gl.h:252
GL_LINE_SMOOTH = 2848 # /usr/include/GL/gl.h:255
GL_LINE_STIPPLE = 2852 # /usr/include/GL/gl.h:256
GL_LINE_STIPPLE_PATTERN = 2853 # /usr/include/GL/gl.h:257
GL_LINE_STIPPLE_REPEAT = 2854 # /usr/include/GL/gl.h:258
GL_LINE_WIDTH = 2849 # /usr/include/GL/gl.h:259
GL_LINE_WIDTH_GRANULARITY = 2851 # /usr/include/GL/gl.h:260
GL_LINE_WIDTH_RANGE = 2850 # /usr/include/GL/gl.h:261
GL_POINT = 6912 # /usr/include/GL/gl.h:264
GL_LINE = 6913 # /usr/include/GL/gl.h:265
GL_FILL = 6914 # /usr/include/GL/gl.h:266
GL_CW = 2304 # /usr/include/GL/gl.h:267
GL_CCW = 2305 # /usr/include/GL/gl.h:268
GL_FRONT = 1028 # /usr/include/GL/gl.h:269
GL_BACK = 1029 # /usr/include/GL/gl.h:270
GL_POLYGON_MODE = 2880 # /usr/include/GL/gl.h:271
GL_POLYGON_SMOOTH = 2881 # /usr/include/GL/gl.h:272
GL_POLYGON_STIPPLE = 2882 # /usr/include/GL/gl.h:273
GL_EDGE_FLAG = 2883 # /usr/include/GL/gl.h:274
GL_CULL_FACE = 2884 # /usr/include/GL/gl.h:275
GL_CULL_FACE_MODE = 2885 # /usr/include/GL/gl.h:276
GL_FRONT_FACE = 2886 # /usr/include/GL/gl.h:277
GL_POLYGON_OFFSET_FACTOR = 32824 # /usr/include/GL/gl.h:278
GL_POLYGON_OFFSET_UNITS = 10752 # /usr/include/GL/gl.h:279
GL_POLYGON_OFFSET_POINT = 10753 # /usr/include/GL/gl.h:280
GL_POLYGON_OFFSET_LINE = 10754 # /usr/include/GL/gl.h:281
GL_POLYGON_OFFSET_FILL = 32823 # /usr/include/GL/gl.h:282
GL_COMPILE = 4864 # /usr/include/GL/gl.h:285
GL_COMPILE_AND_EXECUTE = 4865 # /usr/include/GL/gl.h:286
GL_LIST_BASE = 2866 # /usr/include/GL/gl.h:287
GL_LIST_INDEX = 2867 # /usr/include/GL/gl.h:288
GL_LIST_MODE = 2864 # /usr/include/GL/gl.h:289
GL_NEVER = 512 # /usr/include/GL/gl.h:292
GL_LESS = 513 # /usr/include/GL/gl.h:293
GL_EQUAL = 514 # /usr/include/GL/gl.h:294
GL_LEQUAL = 515 # /usr/include/GL/gl.h:295
GL_GREATER = 516 # /usr/include/GL/gl.h:296
GL_NOTEQUAL = 517 # /usr/include/GL/gl.h:297
GL_GEQUAL = 518 # /usr/include/GL/gl.h:298
GL_ALWAYS = 519 # /usr/include/GL/gl.h:299
GL_DEPTH_TEST = 2929 # /usr/include/GL/gl.h:300
GL_DEPTH_BITS = 3414 # /usr/include/GL/gl.h:301
GL_DEPTH_CLEAR_VALUE = 2931 # /usr/include/GL/gl.h:302
GL_DEPTH_FUNC = 2932 # /usr/include/GL/gl.h:303
GL_DEPTH_RANGE = 2928 # /usr/include/GL/gl.h:304
GL_DEPTH_WRITEMASK = 2930 # /usr/include/GL/gl.h:305
GL_DEPTH_COMPONENT = 6402 # /usr/include/GL/gl.h:306
GL_LIGHTING = 2896 # /usr/include/GL/gl.h:309
GL_LIGHT0 = 16384 # /usr/include/GL/gl.h:310
GL_LIGHT1 = 16385 # /usr/include/GL/gl.h:311
GL_LIGHT2 = 16386 # /usr/include/GL/gl.h:312
GL_LIGHT3 = 16387 # /usr/include/GL/gl.h:313
GL_LIGHT4 = 16388 # /usr/include/GL/gl.h:314
GL_LIGHT5 = 16389 # /usr/include/GL/gl.h:315
GL_LIGHT6 = 16390 # /usr/include/GL/gl.h:316
GL_LIGHT7 = 16391 # /usr/include/GL/gl.h:317
GL_SPOT_EXPONENT = 4613 # /usr/include/GL/gl.h:318
GL_SPOT_CUTOFF = 4614 # /usr/include/GL/gl.h:319
GL_CONSTANT_ATTENUATION = 4615 # /usr/include/GL/gl.h:320
GL_LINEAR_ATTENUATION = 4616 # /usr/include/GL/gl.h:321
GL_QUADRATIC_ATTENUATION = 4617 # /usr/include/GL/gl.h:322
GL_AMBIENT = 4608 # /usr/include/GL/gl.h:323
GL_DIFFUSE = 4609 # /usr/include/GL/gl.h:324
GL_SPECULAR = 4610 # /usr/include/GL/gl.h:325
GL_SHININESS = 5633 # /usr/include/GL/gl.h:326
GL_EMISSION = 5632 # /usr/include/GL/gl.h:327
GL_POSITION = 4611 # /usr/include/GL/gl.h:328
GL_SPOT_DIRECTION = 4612 # /usr/include/GL/gl.h:329
GL_AMBIENT_AND_DIFFUSE = 5634 # /usr/include/GL/gl.h:330
GL_COLOR_INDEXES = 5635 # /usr/include/GL/gl.h:331
GL_LIGHT_MODEL_TWO_SIDE = 2898 # /usr/include/GL/gl.h:332
GL_LIGHT_MODEL_LOCAL_VIEWER = 2897 # /usr/include/GL/gl.h:333
GL_LIGHT_MODEL_AMBIENT = 2899 # /usr/include/GL/gl.h:334
GL_FRONT_AND_BACK = 1032 # /usr/include/GL/gl.h:335
GL_SHADE_MODEL = 2900 # /usr/include/GL/gl.h:336
GL_FLAT = 7424 # /usr/include/GL/gl.h:337
GL_SMOOTH = 7425 # /usr/include/GL/gl.h:338
GL_COLOR_MATERIAL = 2903 # /usr/include/GL/gl.h:339
GL_COLOR_MATERIAL_FACE = 2901 # /usr/include/GL/gl.h:340
GL_COLOR_MATERIAL_PARAMETER = 2902 # /usr/include/GL/gl.h:341
GL_NORMALIZE = 2977 # /usr/include/GL/gl.h:342
GL_CLIP_PLANE0 = 12288 # /usr/include/GL/gl.h:345
GL_CLIP_PLANE1 = 12289 # /usr/include/GL/gl.h:346
GL_CLIP_PLANE2 = 12290 # /usr/include/GL/gl.h:347
GL_CLIP_PLANE3 = 12291 # /usr/include/GL/gl.h:348
GL_CLIP_PLANE4 = 12292 # /usr/include/GL/gl.h:349
GL_CLIP_PLANE5 = 12293 # /usr/include/GL/gl.h:350
GL_ACCUM_RED_BITS = 3416 # /usr/include/GL/gl.h:353
GL_ACCUM_GREEN_BITS = 3417 # /usr/include/GL/gl.h:354
GL_ACCUM_BLUE_BITS = 3418 # /usr/include/GL/gl.h:355
GL_ACCUM_ALPHA_BITS = 3419 # /usr/include/GL/gl.h:356
GL_ACCUM_CLEAR_VALUE = 2944 # /usr/include/GL/gl.h:357
GL_ACCUM = 256 # /usr/include/GL/gl.h:358
GL_ADD = 260 # /usr/include/GL/gl.h:359
GL_LOAD = 257 # /usr/include/GL/gl.h:360
GL_MULT = 259 # /usr/include/GL/gl.h:361
GL_RETURN = 258 # /usr/include/GL/gl.h:362
GL_ALPHA_TEST = 3008 # /usr/include/GL/gl.h:365
GL_ALPHA_TEST_REF = 3010 # /usr/include/GL/gl.h:366
GL_ALPHA_TEST_FUNC = 3009 # /usr/include/GL/gl.h:367
GL_BLEND = 3042 # /usr/include/GL/gl.h:370
GL_BLEND_SRC = 3041 # /usr/include/GL/gl.h:371
GL_BLEND_DST = 3040 # /usr/include/GL/gl.h:372
GL_ZERO = 0 # /usr/include/GL/gl.h:373
GL_ONE = 1 # /usr/include/GL/gl.h:374
GL_SRC_COLOR = 768 # /usr/include/GL/gl.h:375
GL_ONE_MINUS_SRC_COLOR = 769 # /usr/include/GL/gl.h:376
GL_SRC_ALPHA = 770 # /usr/include/GL/gl.h:377
GL_ONE_MINUS_SRC_ALPHA = 771 # /usr/include/GL/gl.h:378
GL_DST_ALPHA = 772 # /usr/include/GL/gl.h:379
GL_ONE_MINUS_DST_ALPHA = 773 # /usr/include/GL/gl.h:380
GL_DST_COLOR = 774 # /usr/include/GL/gl.h:381
GL_ONE_MINUS_DST_COLOR = 775 # /usr/include/GL/gl.h:382
GL_SRC_ALPHA_SATURATE = 776 # /usr/include/GL/gl.h:383
GL_FEEDBACK = 7169 # /usr/include/GL/gl.h:386
GL_RENDER = 7168 # /usr/include/GL/gl.h:387
GL_SELECT = 7170 # /usr/include/GL/gl.h:388
GL_2D = 1536 # /usr/include/GL/gl.h:391
GL_3D = 1537 # /usr/include/GL/gl.h:392
GL_3D_COLOR = 1538 # /usr/include/GL/gl.h:393
GL_3D_COLOR_TEXTURE = 1539 # /usr/include/GL/gl.h:394
GL_4D_COLOR_TEXTURE = 1540 # /usr/include/GL/gl.h:395
GL_POINT_TOKEN = 1793 # /usr/include/GL/gl.h:396
GL_LINE_TOKEN = 1794 # /usr/include/GL/gl.h:397
GL_LINE_RESET_TOKEN = 1799 # /usr/include/GL/gl.h:398
GL_POLYGON_TOKEN = 1795 # /usr/include/GL/gl.h:399
GL_BITMAP_TOKEN = 1796 # /usr/include/GL/gl.h:400
GL_DRAW_PIXEL_TOKEN = 1797 # /usr/include/GL/gl.h:401
GL_COPY_PIXEL_TOKEN = 1798 # /usr/include/GL/gl.h:402
GL_PASS_THROUGH_TOKEN = 1792 # /usr/include/GL/gl.h:403
GL_FEEDBACK_BUFFER_POINTER = 3568 # /usr/include/GL/gl.h:404
GL_FEEDBACK_BUFFER_SIZE = 3569 # /usr/include/GL/gl.h:405
GL_FEEDBACK_BUFFER_TYPE = 3570 # /usr/include/GL/gl.h:406
GL_SELECTION_BUFFER_POINTER = 3571 # /usr/include/GL/gl.h:409
GL_SELECTION_BUFFER_SIZE = 3572 # /usr/include/GL/gl.h:410
GL_FOG = 2912 # /usr/include/GL/gl.h:413
GL_FOG_MODE = 2917 # /usr/include/GL/gl.h:414
GL_FOG_DENSITY = 2914 # /usr/include/GL/gl.h:415
GL_FOG_COLOR = 2918 # /usr/include/GL/gl.h:416
GL_FOG_INDEX = 2913 # /usr/include/GL/gl.h:417
GL_FOG_START = 2915 # /usr/include/GL/gl.h:418
GL_FOG_END = 2916 # /usr/include/GL/gl.h:419
GL_LINEAR = 9729 # /usr/include/GL/gl.h:420
GL_EXP = 2048 # /usr/include/GL/gl.h:421
GL_EXP2 = 2049 # /usr/include/GL/gl.h:422
GL_LOGIC_OP = 3057 # /usr/include/GL/gl.h:425
GL_INDEX_LOGIC_OP = 3057 # /usr/include/GL/gl.h:426
GL_COLOR_LOGIC_OP = 3058 # /usr/include/GL/gl.h:427
GL_LOGIC_OP_MODE = 3056 # /usr/include/GL/gl.h:428
GL_CLEAR = 5376 # /usr/include/GL/gl.h:429
GL_SET = 5391 # /usr/include/GL/gl.h:430
GL_COPY = 5379 # /usr/include/GL/gl.h:431
GL_COPY_INVERTED = 5388 # /usr/include/GL/gl.h:432
GL_NOOP = 5381 # /usr/include/GL/gl.h:433
GL_INVERT = 5386 # /usr/include/GL/gl.h:434
GL_AND = 5377 # /usr/include/GL/gl.h:435
GL_NAND = 5390 # /usr/include/GL/gl.h:436
GL_OR = 5383 # /usr/include/GL/gl.h:437
GL_NOR = 5384 # /usr/include/GL/gl.h:438
GL_XOR = 5382 # /usr/include/GL/gl.h:439
GL_EQUIV = 5385 # /usr/include/GL/gl.h:440
GL_AND_REVERSE = 5378 # /usr/include/GL/gl.h:441
GL_AND_INVERTED = 5380 # /usr/include/GL/gl.h:442
GL_OR_REVERSE = 5387 # /usr/include/GL/gl.h:443
GL_OR_INVERTED = 5389 # /usr/include/GL/gl.h:444
GL_STENCIL_BITS = 3415 # /usr/include/GL/gl.h:447
GL_STENCIL_TEST = 2960 # /usr/include/GL/gl.h:448
GL_STENCIL_CLEAR_VALUE = 2961 # /usr/include/GL/gl.h:449
GL_STENCIL_FUNC = 2962 # /usr/include/GL/gl.h:450
GL_STENCIL_VALUE_MASK = 2963 # /usr/include/GL/gl.h:451
GL_STENCIL_FAIL = 2964 # /usr/include/GL/gl.h:452
GL_STENCIL_PASS_DEPTH_FAIL = 2965 # /usr/include/GL/gl.h:453
GL_STENCIL_PASS_DEPTH_PASS = 2966 # /usr/include/GL/gl.h:454
GL_STENCIL_REF = 2967 # /usr/include/GL/gl.h:455
GL_STENCIL_WRITEMASK = 2968 # /usr/include/GL/gl.h:456
GL_STENCIL_INDEX = 6401 # /usr/include/GL/gl.h:457
GL_KEEP = 7680 # /usr/include/GL/gl.h:458
GL_REPLACE = 7681 # /usr/include/GL/gl.h:459
GL_INCR = 7682 # /usr/include/GL/gl.h:460
GL_DECR = 7683 # /usr/include/GL/gl.h:461
GL_NONE = 0 # /usr/include/GL/gl.h:464
GL_LEFT = 1030 # /usr/include/GL/gl.h:465
GL_RIGHT = 1031 # /usr/include/GL/gl.h:466
GL_FRONT_LEFT = 1024 # /usr/include/GL/gl.h:470
GL_FRONT_RIGHT = 1025 # /usr/include/GL/gl.h:471
GL_BACK_LEFT = 1026 # /usr/include/GL/gl.h:472
GL_BACK_RIGHT = 1027 # /usr/include/GL/gl.h:473
GL_AUX0 = 1033 # /usr/include/GL/gl.h:474
GL_AUX1 = 1034 # /usr/include/GL/gl.h:475
GL_AUX2 = 1035 # /usr/include/GL/gl.h:476
GL_AUX3 = 1036 # /usr/include/GL/gl.h:477
GL_COLOR_INDEX = 6400 # /usr/include/GL/gl.h:478
GL_RED = 6403 # /usr/include/GL/gl.h:479
GL_GREEN = 6404 # /usr/include/GL/gl.h:480
GL_BLUE = 6405 # /usr/include/GL/gl.h:481
GL_ALPHA = 6406 # /usr/include/GL/gl.h:482
GL_LUMINANCE = 6409 # /usr/include/GL/gl.h:483
GL_LUMINANCE_ALPHA = 6410 # /usr/include/GL/gl.h:484
GL_ALPHA_BITS = 3413 # /usr/include/GL/gl.h:485
GL_RED_BITS = 3410 # /usr/include/GL/gl.h:486
GL_GREEN_BITS = 3411 # /usr/include/GL/gl.h:487
GL_BLUE_BITS = 3412 # /usr/include/GL/gl.h:488
GL_INDEX_BITS = 3409 # /usr/include/GL/gl.h:489
GL_SUBPIXEL_BITS = 3408 # /usr/include/GL/gl.h:490
GL_AUX_BUFFERS = 3072 # /usr/include/GL/gl.h:491
GL_READ_BUFFER = 3074 # /usr/include/GL/gl.h:492
GL_DRAW_BUFFER = 3073 # /usr/include/GL/gl.h:493
GL_DOUBLEBUFFER = 3122 # /usr/include/GL/gl.h:494
GL_STEREO = 3123 # /usr/include/GL/gl.h:495
GL_BITMAP = 6656 # /usr/include/GL/gl.h:496
GL_COLOR = 6144 # /usr/include/GL/gl.h:497
GL_DEPTH = 6145 # /usr/include/GL/gl.h:498
GL_STENCIL = 6146 # /usr/include/GL/gl.h:499
GL_DITHER = 3024 # /usr/include/GL/gl.h:500
GL_RGB = 6407 # /usr/include/GL/gl.h:501
GL_RGBA = 6408 # /usr/include/GL/gl.h:502
GL_MAX_LIST_NESTING = 2865 # /usr/include/GL/gl.h:505
GL_MAX_EVAL_ORDER = 3376 # /usr/include/GL/gl.h:506
GL_MAX_LIGHTS = 3377 # /usr/include/GL/gl.h:507
GL_MAX_CLIP_PLANES = 3378 # /usr/include/GL/gl.h:508
GL_MAX_TEXTURE_SIZE = 3379 # /usr/include/GL/gl.h:509
GL_MAX_PIXEL_MAP_TABLE = 3380 # /usr/include/GL/gl.h:510
GL_MAX_ATTRIB_STACK_DEPTH = 3381 # /usr/include/GL/gl.h:511
GL_MAX_MODELVIEW_STACK_DEPTH = 3382 # /usr/include/GL/gl.h:512
GL_MAX_NAME_STACK_DEPTH = 3383 # /usr/include/GL/gl.h:513
GL_MAX_PROJECTION_STACK_DEPTH = 3384 # /usr/include/GL/gl.h:514
GL_MAX_TEXTURE_STACK_DEPTH = 3385 # /usr/include/GL/gl.h:515
GL_MAX_VIEWPORT_DIMS = 3386 # /usr/include/GL/gl.h:516
GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 3387 # /usr/include/GL/gl.h:517
GL_ATTRIB_STACK_DEPTH = 2992 # /usr/include/GL/gl.h:520
GL_CLIENT_ATTRIB_STACK_DEPTH = 2993 # /usr/include/GL/gl.h:521
GL_COLOR_CLEAR_VALUE = 3106 # /usr/include/GL/gl.h:522
GL_COLOR_WRITEMASK = 3107 # /usr/include/GL/gl.h:523
GL_CURRENT_INDEX = 2817 # /usr/include/GL/gl.h:524
GL_CURRENT_COLOR = 2816 # /usr/include/GL/gl.h:525
GL_CURRENT_NORMAL = 2818 # /usr/include/GL/gl.h:526
GL_CURRENT_RASTER_COLOR = 2820 # /usr/include/GL/gl.h:527
GL_CURRENT_RASTER_DISTANCE = 2825 # /usr/include/GL/gl.h:528
GL_CURRENT_RASTER_INDEX = 2821 # /usr/include/GL/gl.h:529
GL_CURRENT_RASTER_POSITION = 2823 # /usr/include/GL/gl.h:530
GL_CURRENT_RASTER_TEXTURE_COORDS = 2822 # /usr/include/GL/gl.h:531
GL_CURRENT_RASTER_POSITION_VALID = 2824 # /usr/include/GL/gl.h:532
GL_CURRENT_TEXTURE_COORDS = 2819 # /usr/include/GL/gl.h:533
GL_INDEX_CLEAR_VALUE = 3104 # /usr/include/GL/gl.h:534
GL_INDEX_MODE = 3120 # /usr/include/GL/gl.h:535
GL_INDEX_WRITEMASK = 3105 # /usr/include/GL/gl.h:536
GL_MODELVIEW_MATRIX = 2982 # /usr/include/GL/gl.h:537
GL_MODELVIEW_STACK_DEPTH = 2979 # /usr/include/GL/gl.h:538
GL_NAME_STACK_DEPTH = 3440 # /usr/include/GL/gl.h:539
GL_PROJECTION_MATRIX = 2983 # /usr/include/GL/gl.h:540
GL_PROJECTION_STACK_DEPTH = 2980 # /usr/include/GL/gl.h:541
GL_RENDER_MODE = 3136 # /usr/include/GL/gl.h:542
GL_RGBA_MODE = 3121 # /usr/include/GL/gl.h:543
GL_TEXTURE_MATRIX = 2984 # /usr/include/GL/gl.h:544
GL_TEXTURE_STACK_DEPTH = 2981 # /usr/include/GL/gl.h:545
GL_VIEWPORT = 2978 # /usr/include/GL/gl.h:546
GL_AUTO_NORMAL = 3456 # /usr/include/GL/gl.h:549
GL_MAP1_COLOR_4 = 3472 # /usr/include/GL/gl.h:550
GL_MAP1_INDEX = 3473 # /usr/include/GL/gl.h:551
GL_MAP1_NORMAL = 3474 # /usr/include/GL/gl.h:552
GL_MAP1_TEXTURE_COORD_1 = 3475 # /usr/include/GL/gl.h:553
GL_MAP1_TEXTURE_COORD_2 = 3476 # /usr/include/GL/gl.h:554
GL_MAP1_TEXTURE_COORD_3 = 3477 # /usr/include/GL/gl.h:555
GL_MAP1_TEXTURE_COORD_4 = 3478 # /usr/include/GL/gl.h:556
GL_MAP1_VERTEX_3 = 3479 # /usr/include/GL/gl.h:557
GL_MAP1_VERTEX_4 = 3480 # /usr/include/GL/gl.h:558
GL_MAP2_COLOR_4 = 3504 # /usr/include/GL/gl.h:559
GL_MAP2_INDEX = 3505 # /usr/include/GL/gl.h:560
GL_MAP2_NORMAL = 3506 # /usr/include/GL/gl.h:561
GL_MAP2_TEXTURE_COORD_1 = 3507 # /usr/include/GL/gl.h:562
GL_MAP2_TEXTURE_COORD_2 = 3508 # /usr/include/GL/gl.h:563
GL_MAP2_TEXTURE_COORD_3 = 3509 # /usr/include/GL/gl.h:564
GL_MAP2_TEXTURE_COORD_4 = 3510 # /usr/include/GL/gl.h:565
GL_MAP2_VERTEX_3 = 3511 # /usr/include/GL/gl.h:566
GL_MAP2_VERTEX_4 = 3512 # /usr/include/GL/gl.h:567
GL_MAP1_GRID_DOMAIN = 3536 # /usr/include/GL/gl.h:568
GL_MAP1_GRID_SEGMENTS = 3537 # /usr/include/GL/gl.h:569
GL_MAP2_GRID_DOMAIN = 3538 # /usr/include/GL/gl.h:570
GL_MAP2_GRID_SEGMENTS = 3539 # /usr/include/GL/gl.h:571
GL_COEFF = 2560 # /usr/include/GL/gl.h:572
GL_ORDER = 2561 # /usr/include/GL/gl.h:573
GL_DOMAIN = 2562 # /usr/include/GL/gl.h:574
GL_PERSPECTIVE_CORRECTION_HINT = 3152 # /usr/include/GL/gl.h:577
GL_POINT_SMOOTH_HINT = 3153 # /usr/include/GL/gl.h:578
GL_LINE_SMOOTH_HINT = 3154 # /usr/include/GL/gl.h:579
GL_POLYGON_SMOOTH_HINT = 3155 # /usr/include/GL/gl.h:580
GL_FOG_HINT = 3156 # /usr/include/GL/gl.h:581
GL_DONT_CARE = 4352 # /usr/include/GL/gl.h:582
GL_FASTEST = 4353 # /usr/include/GL/gl.h:583
GL_NICEST = 4354 # /usr/include/GL/gl.h:584
GL_SCISSOR_BOX = 3088 # /usr/include/GL/gl.h:587
GL_SCISSOR_TEST = 3089 # /usr/include/GL/gl.h:588
GL_MAP_COLOR = 3344 # /usr/include/GL/gl.h:591
GL_MAP_STENCIL = 3345 # /usr/include/GL/gl.h:592
GL_INDEX_SHIFT = 3346 # /usr/include/GL/gl.h:593
GL_INDEX_OFFSET = 3347 # /usr/include/GL/gl.h:594
GL_RED_SCALE = 3348 # /usr/include/GL/gl.h:595
GL_RED_BIAS = 3349 # /usr/include/GL/gl.h:596
GL_GREEN_SCALE = 3352 # /usr/include/GL/gl.h:597
GL_GREEN_BIAS = 3353 # /usr/include/GL/gl.h:598
GL_BLUE_SCALE = 3354 # /usr/include/GL/gl.h:599
GL_BLUE_BIAS = 3355 # /usr/include/GL/gl.h:600
GL_ALPHA_SCALE = 3356 # /usr/include/GL/gl.h:601
GL_ALPHA_BIAS = 3357 # /usr/include/GL/gl.h:602
GL_DEPTH_SCALE = 3358 # /usr/include/GL/gl.h:603
GL_DEPTH_BIAS = 3359 # /usr/include/GL/gl.h:604
GL_PIXEL_MAP_S_TO_S_SIZE = 3249 # /usr/include/GL/gl.h:605
GL_PIXEL_MAP_I_TO_I_SIZE = 3248 # /usr/include/GL/gl.h:606
GL_PIXEL_MAP_I_TO_R_SIZE = 3250 # /usr/include/GL/gl.h:607
GL_PIXEL_MAP_I_TO_G_SIZE = 3251 # /usr/include/GL/gl.h:608
GL_PIXEL_MAP_I_TO_B_SIZE = 3252 # /usr/include/GL/gl.h:609
GL_PIXEL_MAP_I_TO_A_SIZE = 3253 # /usr/include/GL/gl.h:610
GL_PIXEL_MAP_R_TO_R_SIZE = 3254 # /usr/include/GL/gl.h:611
GL_PIXEL_MAP_G_TO_G_SIZE = 3255 # /usr/include/GL/gl.h:612
GL_PIXEL_MAP_B_TO_B_SIZE = 3256 # /usr/include/GL/gl.h:613
GL_PIXEL_MAP_A_TO_A_SIZE = 3257 # /usr/include/GL/gl.h:614
GL_PIXEL_MAP_S_TO_S = 3185 # /usr/include/GL/gl.h:615
GL_PIXEL_MAP_I_TO_I = 3184 # /usr/include/GL/gl.h:616
GL_PIXEL_MAP_I_TO_R = 3186 # /usr/include/GL/gl.h:617
GL_PIXEL_MAP_I_TO_G = 3187 # /usr/include/GL/gl.h:618
GL_PIXEL_MAP_I_TO_B = 3188 # /usr/include/GL/gl.h:619
GL_PIXEL_MAP_I_TO_A = 3189 # /usr/include/GL/gl.h:620
GL_PIXEL_MAP_R_TO_R = 3190 # /usr/include/GL/gl.h:621
GL_PIXEL_MAP_G_TO_G = 3191 # /usr/include/GL/gl.h:622
GL_PIXEL_MAP_B_TO_B = 3192 # /usr/include/GL/gl.h:623
GL_PIXEL_MAP_A_TO_A = 3193 # /usr/include/GL/gl.h:624
GL_PACK_ALIGNMENT = 3333 # /usr/include/GL/gl.h:625
GL_PACK_LSB_FIRST = 3329 # /usr/include/GL/gl.h:626
GL_PACK_ROW_LENGTH = 3330 # /usr/include/GL/gl.h:627
GL_PACK_SKIP_PIXELS = 3332 # /usr/include/GL/gl.h:628
GL_PACK_SKIP_ROWS = 3331 # /usr/include/GL/gl.h:629
GL_PACK_SWAP_BYTES = 3328 # /usr/include/GL/gl.h:630
GL_UNPACK_ALIGNMENT = 3317 # /usr/include/GL/gl.h:631
GL_UNPACK_LSB_FIRST = 3313 # /usr/include/GL/gl.h:632
GL_UNPACK_ROW_LENGTH = 3314 # /usr/include/GL/gl.h:633
GL_UNPACK_SKIP_PIXELS = 3316 # /usr/include/GL/gl.h:634
GL_UNPACK_SKIP_ROWS = 3315 # /usr/include/GL/gl.h:635
GL_UNPACK_SWAP_BYTES = 3312 # /usr/include/GL/gl.h:636
GL_ZOOM_X = 3350 # /usr/include/GL/gl.h:637
GL_ZOOM_Y = 3351 # /usr/include/GL/gl.h:638
GL_TEXTURE_ENV = 8960 # /usr/include/GL/gl.h:641
GL_TEXTURE_ENV_MODE = 8704 # /usr/include/GL/gl.h:642
GL_TEXTURE_1D = 3552 # /usr/include/GL/gl.h:643
GL_TEXTURE_2D = 3553 # /usr/include/GL/gl.h:644
GL_TEXTURE_WRAP_S = 10242 # /usr/include/GL/gl.h:645
GL_TEXTURE_WRAP_T = 10243 # /usr/include/GL/gl.h:646
GL_TEXTURE_MAG_FILTER = 10240 # /usr/include/GL/gl.h:647
GL_TEXTURE_MIN_FILTER = 10241 # /usr/include/GL/gl.h:648
GL_TEXTURE_ENV_COLOR = 8705 # /usr/include/GL/gl.h:649
GL_TEXTURE_GEN_S = 3168 # /usr/include/GL/gl.h:650
GL_TEXTURE_GEN_T = 3169 # /usr/include/GL/gl.h:651
GL_TEXTURE_GEN_R = 3170 # /usr/include/GL/gl.h:652
GL_TEXTURE_GEN_Q = 3171 # /usr/include/GL/gl.h:653
GL_TEXTURE_GEN_MODE = 9472 # /usr/include/GL/gl.h:654
GL_TEXTURE_BORDER_COLOR = 4100 # /usr/include/GL/gl.h:655
GL_TEXTURE_WIDTH = 4096 # /usr/include/GL/gl.h:656
GL_TEXTURE_HEIGHT = 4097 # /usr/include/GL/gl.h:657
GL_TEXTURE_BORDER = 4101 # /usr/include/GL/gl.h:658
GL_TEXTURE_COMPONENTS = 4099 # /usr/include/GL/gl.h:659
GL_TEXTURE_RED_SIZE = 32860 # /usr/include/GL/gl.h:660
GL_TEXTURE_GREEN_SIZE = 32861 # /usr/include/GL/gl.h:661
GL_TEXTURE_BLUE_SIZE = 32862 # /usr/include/GL/gl.h:662
GL_TEXTURE_ALPHA_SIZE = 32863 # /usr/include/GL/gl.h:663
GL_TEXTURE_LUMINANCE_SIZE = 32864 # /usr/include/GL/gl.h:664
GL_TEXTURE_INTENSITY_SIZE = 32865 # /usr/include/GL/gl.h:665
GL_NEAREST_MIPMAP_NEAREST = 9984 # /usr/include/GL/gl.h:666
GL_NEAREST_MIPMAP_LINEAR = 9986 # /usr/include/GL/gl.h:667
GL_LINEAR_MIPMAP_NEAREST = 9985 # /usr/include/GL/gl.h:668
GL_LINEAR_MIPMAP_LINEAR = 9987 # /usr/include/GL/gl.h:669
GL_OBJECT_LINEAR = 9217 # /usr/include/GL/gl.h:670
GL_OBJECT_PLANE = 9473 # /usr/include/GL/gl.h:671
GL_EYE_LINEAR = 9216 # /usr/include/GL/gl.h:672
GL_EYE_PLANE = 9474 # /usr/include/GL/gl.h:673
GL_SPHERE_MAP = 9218 # /usr/include/GL/gl.h:674
GL_DECAL = 8449 # /usr/include/GL/gl.h:675
GL_MODULATE = 8448 # /usr/include/GL/gl.h:676
GL_NEAREST = 9728 # /usr/include/GL/gl.h:677
GL_REPEAT = 10497 # /usr/include/GL/gl.h:678
GL_CLAMP = 10496 # /usr/include/GL/gl.h:679
GL_S = 8192 # /usr/include/GL/gl.h:680
GL_T = 8193 # /usr/include/GL/gl.h:681
GL_R = 8194 # /usr/include/GL/gl.h:682
GL_Q = 8195 # /usr/include/GL/gl.h:683
GL_VENDOR = 7936 # /usr/include/GL/gl.h:686
GL_RENDERER = 7937 # /usr/include/GL/gl.h:687
GL_VERSION = 7938 # /usr/include/GL/gl.h:688
GL_EXTENSIONS = 7939 # /usr/include/GL/gl.h:689
GL_NO_ERROR = 0 # /usr/include/GL/gl.h:692
GL_INVALID_ENUM = 1280 # /usr/include/GL/gl.h:693
GL_INVALID_VALUE = 1281 # /usr/include/GL/gl.h:694
GL_INVALID_OPERATION = 1282 # /usr/include/GL/gl.h:695
GL_STACK_OVERFLOW = 1283 # /usr/include/GL/gl.h:696
GL_STACK_UNDERFLOW = 1284 # /usr/include/GL/gl.h:697
GL_OUT_OF_MEMORY = 1285 # /usr/include/GL/gl.h:698
GL_CURRENT_BIT = 1 # /usr/include/GL/gl.h:701
GL_POINT_BIT = 2 # /usr/include/GL/gl.h:702
GL_LINE_BIT = 4 # /usr/include/GL/gl.h:703
GL_POLYGON_BIT = 8 # /usr/include/GL/gl.h:704
GL_POLYGON_STIPPLE_BIT = 16 # /usr/include/GL/gl.h:705
GL_PIXEL_MODE_BIT = 32 # /usr/include/GL/gl.h:706
GL_LIGHTING_BIT = 64 # /usr/include/GL/gl.h:707
GL_FOG_BIT = 128 # /usr/include/GL/gl.h:708
GL_DEPTH_BUFFER_BIT = 256 # /usr/include/GL/gl.h:709
GL_ACCUM_BUFFER_BIT = 512 # /usr/include/GL/gl.h:710
GL_STENCIL_BUFFER_BIT = 1024 # /usr/include/GL/gl.h:711
GL_VIEWPORT_BIT = 2048 # /usr/include/GL/gl.h:712
GL_TRANSFORM_BIT = 4096 # /usr/include/GL/gl.h:713
GL_ENABLE_BIT = 8192 # /usr/include/GL/gl.h:714
GL_COLOR_BUFFER_BIT = 16384 # /usr/include/GL/gl.h:715
GL_HINT_BIT = 32768 # /usr/include/GL/gl.h:716
GL_EVAL_BIT = 65536 # /usr/include/GL/gl.h:717
GL_LIST_BIT = 131072 # /usr/include/GL/gl.h:718
GL_TEXTURE_BIT = 262144 # /usr/include/GL/gl.h:719
GL_SCISSOR_BIT = 524288 # /usr/include/GL/gl.h:720
GL_ALL_ATTRIB_BITS = 1048575 # /usr/include/GL/gl.h:721
GL_PROXY_TEXTURE_1D = 32867 # /usr/include/GL/gl.h:725
GL_PROXY_TEXTURE_2D = 32868 # /usr/include/GL/gl.h:726
GL_TEXTURE_PRIORITY = 32870 # /usr/include/GL/gl.h:727
GL_TEXTURE_RESIDENT = 32871 # /usr/include/GL/gl.h:728
GL_TEXTURE_BINDING_1D = 32872 # /usr/include/GL/gl.h:729
GL_TEXTURE_BINDING_2D = 32873 # /usr/include/GL/gl.h:730
GL_TEXTURE_INTERNAL_FORMAT = 4099 # /usr/include/GL/gl.h:731
GL_ALPHA4 = 32827 # /usr/include/GL/gl.h:732
GL_ALPHA8 = 32828 # /usr/include/GL/gl.h:733
GL_ALPHA12 = 32829 # /usr/include/GL/gl.h:734
GL_ALPHA16 = 32830 # /usr/include/GL/gl.h:735
GL_LUMINANCE4 = 32831 # /usr/include/GL/gl.h:736
GL_LUMINANCE8 = 32832 # /usr/include/GL/gl.h:737
GL_LUMINANCE12 = 32833 # /usr/include/GL/gl.h:738
GL_LUMINANCE16 = 32834 # /usr/include/GL/gl.h:739
GL_LUMINANCE4_ALPHA4 = 32835 # /usr/include/GL/gl.h:740
GL_LUMINANCE6_ALPHA2 = 32836 # /usr/include/GL/gl.h:741
GL_LUMINANCE8_ALPHA8 = 32837 # /usr/include/GL/gl.h:742
GL_LUMINANCE12_ALPHA4 = 32838 # /usr/include/GL/gl.h:743
GL_LUMINANCE12_ALPHA12 = 32839 # /usr/include/GL/gl.h:744
GL_LUMINANCE16_ALPHA16 = 32840 # /usr/include/GL/gl.h:745
GL_INTENSITY = 32841 # /usr/include/GL/gl.h:746
GL_INTENSITY4 = 32842 # /usr/include/GL/gl.h:747
GL_INTENSITY8 = 32843 # /usr/include/GL/gl.h:748
GL_INTENSITY12 = 32844 # /usr/include/GL/gl.h:749
GL_INTENSITY16 = 32845 # /usr/include/GL/gl.h:750
GL_R3_G3_B2 = 10768 # /usr/include/GL/gl.h:751
GL_RGB4 = 32847 # /usr/include/GL/gl.h:752
GL_RGB5 = 32848 # /usr/include/GL/gl.h:753
GL_RGB8 = 32849 # /usr/include/GL/gl.h:754
GL_RGB10 = 32850 # /usr/include/GL/gl.h:755
GL_RGB12 = 32851 # /usr/include/GL/gl.h:756
GL_RGB16 = 32852 # /usr/include/GL/gl.h:757
GL_RGBA2 = 32853 # /usr/include/GL/gl.h:758
GL_RGBA4 = 32854 # /usr/include/GL/gl.h:759
GL_RGB5_A1 = 32855 # /usr/include/GL/gl.h:760
GL_RGBA8 = 32856 # /usr/include/GL/gl.h:761
GL_RGB10_A2 = 32857 # /usr/include/GL/gl.h:762
GL_RGBA12 = 32858 # /usr/include/GL/gl.h:763
GL_RGBA16 = 32859 # /usr/include/GL/gl.h:764
GL_CLIENT_PIXEL_STORE_BIT = 1 # /usr/include/GL/gl.h:765
GL_CLIENT_VERTEX_ARRAY_BIT = 2 # /usr/include/GL/gl.h:766
GL_ALL_CLIENT_ATTRIB_BITS = 4294967295 # /usr/include/GL/gl.h:767
GL_CLIENT_ALL_ATTRIB_BITS = 4294967295 # /usr/include/GL/gl.h:768
# /usr/include/GL/gl.h:776
glClearIndex = _link_function('glClearIndex', None, [GLfloat], None)
# /usr/include/GL/gl.h:778
glClearColor = _link_function('glClearColor', None, [GLclampf, GLclampf, GLclampf, GLclampf], None)
# /usr/include/GL/gl.h:780
glClear = _link_function('glClear', None, [GLbitfield], None)
# /usr/include/GL/gl.h:782
glIndexMask = _link_function('glIndexMask', None, [GLuint], None)
# /usr/include/GL/gl.h:784
glColorMask = _link_function('glColorMask', None, [GLboolean, GLboolean, GLboolean, GLboolean], None)
# /usr/include/GL/gl.h:786
glAlphaFunc = _link_function('glAlphaFunc', None, [GLenum, GLclampf], None)
# /usr/include/GL/gl.h:788
glBlendFunc = _link_function('glBlendFunc', None, [GLenum, GLenum], None)
# /usr/include/GL/gl.h:790
glLogicOp = _link_function('glLogicOp', None, [GLenum], None)
# /usr/include/GL/gl.h:792
glCullFace = _link_function('glCullFace', None, [GLenum], None)
# /usr/include/GL/gl.h:794
glFrontFace = _link_function('glFrontFace', None, [GLenum], None)
# /usr/include/GL/gl.h:796
glPointSize = _link_function('glPointSize', None, [GLfloat], None)
# /usr/include/GL/gl.h:798
glLineWidth = _link_function('glLineWidth', None, [GLfloat], None)
# /usr/include/GL/gl.h:800
glLineStipple = _link_function('glLineStipple', None, [GLint, GLushort], None)
# /usr/include/GL/gl.h:802
glPolygonMode = _link_function('glPolygonMode', None, [GLenum, GLenum], None)
# /usr/include/GL/gl.h:804
glPolygonOffset = _link_function('glPolygonOffset', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:806
glPolygonStipple = _link_function('glPolygonStipple', None, [POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:808
glGetPolygonStipple = _link_function('glGetPolygonStipple', None, [POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:810
glEdgeFlag = _link_function('glEdgeFlag', None, [GLboolean], None)
# /usr/include/GL/gl.h:812
glEdgeFlagv = _link_function('glEdgeFlagv', None, [POINTER(GLboolean)], None)
# /usr/include/GL/gl.h:814
glScissor = _link_function('glScissor', None, [GLint, GLint, GLsizei, GLsizei], None)
# /usr/include/GL/gl.h:816
glClipPlane = _link_function('glClipPlane', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:818
glGetClipPlane = _link_function('glGetClipPlane', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:820
glDrawBuffer = _link_function('glDrawBuffer', None, [GLenum], None)
# /usr/include/GL/gl.h:822
glReadBuffer = _link_function('glReadBuffer', None, [GLenum], None)
# /usr/include/GL/gl.h:824
glEnable = _link_function('glEnable', None, [GLenum], None)
# /usr/include/GL/gl.h:826
glDisable = _link_function('glDisable', None, [GLenum], None)
# /usr/include/GL/gl.h:828
glIsEnabled = _link_function('glIsEnabled', GLboolean, [GLenum], None)
# /usr/include/GL/gl.h:831
glEnableClientState = _link_function('glEnableClientState', None, [GLenum], None)
# /usr/include/GL/gl.h:833
glDisableClientState = _link_function('glDisableClientState', None, [GLenum], None)
# /usr/include/GL/gl.h:836
glGetBooleanv = _link_function('glGetBooleanv', None, [GLenum, POINTER(GLboolean)], None)
# /usr/include/GL/gl.h:838
glGetDoublev = _link_function('glGetDoublev', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:840
glGetFloatv = _link_function('glGetFloatv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:842
glGetIntegerv = _link_function('glGetIntegerv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:845
glPushAttrib = _link_function('glPushAttrib', None, [GLbitfield], None)
# /usr/include/GL/gl.h:847
glPopAttrib = _link_function('glPopAttrib', None, [], None)
# /usr/include/GL/gl.h:850
glPushClientAttrib = _link_function('glPushClientAttrib', None, [GLbitfield], None)
# /usr/include/GL/gl.h:852
glPopClientAttrib = _link_function('glPopClientAttrib', None, [], None)
# /usr/include/GL/gl.h:855
glRenderMode = _link_function('glRenderMode', GLint, [GLenum], None)
# /usr/include/GL/gl.h:857
glGetError = _link_function('glGetError', GLenum, [], None)
# /usr/include/GL/gl.h:859
glGetString = _link_function('glGetString', POINTER(GLubyte), [GLenum], None)
# /usr/include/GL/gl.h:861
glFinish = _link_function('glFinish', None, [], None)
# /usr/include/GL/gl.h:863
glFlush = _link_function('glFlush', None, [], None)
# /usr/include/GL/gl.h:865
glHint = _link_function('glHint', None, [GLenum, GLenum], None)
# /usr/include/GL/gl.h:872
glClearDepth = _link_function('glClearDepth', None, [GLclampd], None)
# /usr/include/GL/gl.h:874
glDepthFunc = _link_function('glDepthFunc', None, [GLenum], None)
# /usr/include/GL/gl.h:876
glDepthMask = _link_function('glDepthMask', None, [GLboolean], None)
# /usr/include/GL/gl.h:878
glDepthRange = _link_function('glDepthRange', None, [GLclampd, GLclampd], None)
# /usr/include/GL/gl.h:885
glClearAccum = _link_function('glClearAccum', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:887
glAccum = _link_function('glAccum', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:894
glMatrixMode = _link_function('glMatrixMode', None, [GLenum], None)
# /usr/include/GL/gl.h:896
glOrtho = _link_function('glOrtho', None, [GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:900
glFrustum = _link_function('glFrustum', None, [GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:904
glViewport = _link_function('glViewport', None, [GLint, GLint, GLsizei, GLsizei], None)
# /usr/include/GL/gl.h:907
glPushMatrix = _link_function('glPushMatrix', None, [], None)
# /usr/include/GL/gl.h:909
glPopMatrix = _link_function('glPopMatrix', None, [], None)
# /usr/include/GL/gl.h:911
glLoadIdentity = _link_function('glLoadIdentity', None, [], None)
# /usr/include/GL/gl.h:913
glLoadMatrixd = _link_function('glLoadMatrixd', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:914
glLoadMatrixf = _link_function('glLoadMatrixf', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:916
glMultMatrixd = _link_function('glMultMatrixd', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:917
glMultMatrixf = _link_function('glMultMatrixf', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:919
glRotated = _link_function('glRotated', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:921
glRotatef = _link_function('glRotatef', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:924
glScaled = _link_function('glScaled', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:925
glScalef = _link_function('glScalef', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:927
glTranslated = _link_function('glTranslated', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:928
glTranslatef = _link_function('glTranslatef', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:935
glIsList = _link_function('glIsList', GLboolean, [GLuint], None)
# /usr/include/GL/gl.h:937
glDeleteLists = _link_function('glDeleteLists', None, [GLuint, GLsizei], None)
# /usr/include/GL/gl.h:939
glGenLists = _link_function('glGenLists', GLuint, [GLsizei], None)
# /usr/include/GL/gl.h:941
glNewList = _link_function('glNewList', None, [GLuint, GLenum], None)
# /usr/include/GL/gl.h:943
glEndList = _link_function('glEndList', None, [], None)
# /usr/include/GL/gl.h:945
glCallList = _link_function('glCallList', None, [GLuint], None)
# /usr/include/GL/gl.h:947
glCallLists = _link_function('glCallLists', None, [GLsizei, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:950
glListBase = _link_function('glListBase', None, [GLuint], None)
# /usr/include/GL/gl.h:957
glBegin = _link_function('glBegin', None, [GLenum], None)
# /usr/include/GL/gl.h:959
glEnd = _link_function('glEnd', None, [], None)
# /usr/include/GL/gl.h:962
glVertex2d = _link_function('glVertex2d', None, [GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:963
glVertex2f = _link_function('glVertex2f', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:964
glVertex2i = _link_function('glVertex2i', None, [GLint, GLint], None)
# /usr/include/GL/gl.h:965
glVertex2s = _link_function('glVertex2s', None, [GLshort, GLshort], None)
# /usr/include/GL/gl.h:967
glVertex3d = _link_function('glVertex3d', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:968
glVertex3f = _link_function('glVertex3f', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:969
glVertex3i = _link_function('glVertex3i', None, [GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:970
glVertex3s = _link_function('glVertex3s', None, [GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:972
glVertex4d = _link_function('glVertex4d', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:973
glVertex4f = _link_function('glVertex4f', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:974
glVertex4i = _link_function('glVertex4i', None, [GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:975
glVertex4s = _link_function('glVertex4s', None, [GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:977
glVertex2dv = _link_function('glVertex2dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:978
glVertex2fv = _link_function('glVertex2fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:979
glVertex2iv = _link_function('glVertex2iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:980
glVertex2sv = _link_function('glVertex2sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:982
glVertex3dv = _link_function('glVertex3dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:983
glVertex3fv = _link_function('glVertex3fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:984
glVertex3iv = _link_function('glVertex3iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:985
glVertex3sv = _link_function('glVertex3sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:987
glVertex4dv = _link_function('glVertex4dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:988
glVertex4fv = _link_function('glVertex4fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:989
glVertex4iv = _link_function('glVertex4iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:990
glVertex4sv = _link_function('glVertex4sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:993
glNormal3b = _link_function('glNormal3b', None, [GLbyte, GLbyte, GLbyte], None)
# /usr/include/GL/gl.h:994
glNormal3d = _link_function('glNormal3d', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:995
glNormal3f = _link_function('glNormal3f', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:996
glNormal3i = _link_function('glNormal3i', None, [GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:997
glNormal3s = _link_function('glNormal3s', None, [GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:999
glNormal3bv = _link_function('glNormal3bv', None, [POINTER(GLbyte)], None)
# /usr/include/GL/gl.h:1000
glNormal3dv = _link_function('glNormal3dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1001
glNormal3fv = _link_function('glNormal3fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1002
glNormal3iv = _link_function('glNormal3iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1003
glNormal3sv = _link_function('glNormal3sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1006
glIndexd = _link_function('glIndexd', None, [GLdouble], None)
# /usr/include/GL/gl.h:1007
glIndexf = _link_function('glIndexf', None, [GLfloat], None)
# /usr/include/GL/gl.h:1008
glIndexi = _link_function('glIndexi', None, [GLint], None)
# /usr/include/GL/gl.h:1009
glIndexs = _link_function('glIndexs', None, [GLshort], None)
# /usr/include/GL/gl.h:1010
glIndexub = _link_function('glIndexub', None, [GLubyte], None)
# /usr/include/GL/gl.h:1012
glIndexdv = _link_function('glIndexdv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1013
glIndexfv = _link_function('glIndexfv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1014
glIndexiv = _link_function('glIndexiv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1015
glIndexsv = _link_function('glIndexsv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1016
glIndexubv = _link_function('glIndexubv', None, [POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:1018
glColor3b = _link_function('glColor3b', None, [GLbyte, GLbyte, GLbyte], None)
# /usr/include/GL/gl.h:1019
glColor3d = _link_function('glColor3d', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1020
glColor3f = _link_function('glColor3f', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1021
glColor3i = _link_function('glColor3i', None, [GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1022
glColor3s = _link_function('glColor3s', None, [GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1023
glColor3ub = _link_function('glColor3ub', None, [GLubyte, GLubyte, GLubyte], None)
# /usr/include/GL/gl.h:1024
glColor3ui = _link_function('glColor3ui', None, [GLuint, GLuint, GLuint], None)
# /usr/include/GL/gl.h:1025
glColor3us = _link_function('glColor3us', None, [GLushort, GLushort, GLushort], None)
# /usr/include/GL/gl.h:1027
glColor4b = _link_function('glColor4b', None, [GLbyte, GLbyte, GLbyte, GLbyte], None)
# /usr/include/GL/gl.h:1029
glColor4d = _link_function('glColor4d', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1031
glColor4f = _link_function('glColor4f', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1033
glColor4i = _link_function('glColor4i', None, [GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1035
glColor4s = _link_function('glColor4s', None, [GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1037
glColor4ub = _link_function('glColor4ub', None, [GLubyte, GLubyte, GLubyte, GLubyte], None)
# /usr/include/GL/gl.h:1039
glColor4ui = _link_function('glColor4ui', None, [GLuint, GLuint, GLuint, GLuint], None)
# /usr/include/GL/gl.h:1041
glColor4us = _link_function('glColor4us', None, [GLushort, GLushort, GLushort, GLushort], None)
# /usr/include/GL/gl.h:1045
glColor3bv = _link_function('glColor3bv', None, [POINTER(GLbyte)], None)
# /usr/include/GL/gl.h:1046
glColor3dv = _link_function('glColor3dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1047
glColor3fv = _link_function('glColor3fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1048
glColor3iv = _link_function('glColor3iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1049
glColor3sv = _link_function('glColor3sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1050
glColor3ubv = _link_function('glColor3ubv', None, [POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:1051
glColor3uiv = _link_function('glColor3uiv', None, [POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1052
glColor3usv = _link_function('glColor3usv', None, [POINTER(GLushort)], None)
# /usr/include/GL/gl.h:1054
glColor4bv = _link_function('glColor4bv', None, [POINTER(GLbyte)], None)
# /usr/include/GL/gl.h:1055
glColor4dv = _link_function('glColor4dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1056
glColor4fv = _link_function('glColor4fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1057
glColor4iv = _link_function('glColor4iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1058
glColor4sv = _link_function('glColor4sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1059
glColor4ubv = _link_function('glColor4ubv', None, [POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:1060
glColor4uiv = _link_function('glColor4uiv', None, [POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1061
glColor4usv = _link_function('glColor4usv', None, [POINTER(GLushort)], None)
# /usr/include/GL/gl.h:1064
glTexCoord1d = _link_function('glTexCoord1d', None, [GLdouble], None)
# /usr/include/GL/gl.h:1065
glTexCoord1f = _link_function('glTexCoord1f', None, [GLfloat], None)
# /usr/include/GL/gl.h:1066
glTexCoord1i = _link_function('glTexCoord1i', None, [GLint], None)
# /usr/include/GL/gl.h:1067
glTexCoord1s = _link_function('glTexCoord1s', None, [GLshort], None)
# /usr/include/GL/gl.h:1069
glTexCoord2d = _link_function('glTexCoord2d', None, [GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1070
glTexCoord2f = _link_function('glTexCoord2f', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1071
glTexCoord2i = _link_function('glTexCoord2i', None, [GLint, GLint], None)
# /usr/include/GL/gl.h:1072
glTexCoord2s = _link_function('glTexCoord2s', None, [GLshort, GLshort], None)
# /usr/include/GL/gl.h:1074
glTexCoord3d = _link_function('glTexCoord3d', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1075
glTexCoord3f = _link_function('glTexCoord3f', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1076
glTexCoord3i = _link_function('glTexCoord3i', None, [GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1077
glTexCoord3s = _link_function('glTexCoord3s', None, [GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1079
glTexCoord4d = _link_function('glTexCoord4d', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1080
glTexCoord4f = _link_function('glTexCoord4f', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1081
glTexCoord4i = _link_function('glTexCoord4i', None, [GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1082
glTexCoord4s = _link_function('glTexCoord4s', None, [GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1084
glTexCoord1dv = _link_function('glTexCoord1dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1085
glTexCoord1fv = _link_function('glTexCoord1fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1086
glTexCoord1iv = _link_function('glTexCoord1iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1087
glTexCoord1sv = _link_function('glTexCoord1sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1089
glTexCoord2dv = _link_function('glTexCoord2dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1090
glTexCoord2fv = _link_function('glTexCoord2fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1091
glTexCoord2iv = _link_function('glTexCoord2iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1092
glTexCoord2sv = _link_function('glTexCoord2sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1094
glTexCoord3dv = _link_function('glTexCoord3dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1095
glTexCoord3fv = _link_function('glTexCoord3fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1096
glTexCoord3iv = _link_function('glTexCoord3iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1097
glTexCoord3sv = _link_function('glTexCoord3sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1099
glTexCoord4dv = _link_function('glTexCoord4dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1100
glTexCoord4fv = _link_function('glTexCoord4fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1101
glTexCoord4iv = _link_function('glTexCoord4iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1102
glTexCoord4sv = _link_function('glTexCoord4sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1105
glRasterPos2d = _link_function('glRasterPos2d', None, [GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1106
glRasterPos2f = _link_function('glRasterPos2f', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1107
glRasterPos2i = _link_function('glRasterPos2i', None, [GLint, GLint], None)
# /usr/include/GL/gl.h:1108
glRasterPos2s = _link_function('glRasterPos2s', None, [GLshort, GLshort], None)
# /usr/include/GL/gl.h:1110
glRasterPos3d = _link_function('glRasterPos3d', None, [GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1111
glRasterPos3f = _link_function('glRasterPos3f', None, [GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1112
glRasterPos3i = _link_function('glRasterPos3i', None, [GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1113
glRasterPos3s = _link_function('glRasterPos3s', None, [GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1115
glRasterPos4d = _link_function('glRasterPos4d', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1116
glRasterPos4f = _link_function('glRasterPos4f', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1117
glRasterPos4i = _link_function('glRasterPos4i', None, [GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1118
glRasterPos4s = _link_function('glRasterPos4s', None, [GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1120
glRasterPos2dv = _link_function('glRasterPos2dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1121
glRasterPos2fv = _link_function('glRasterPos2fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1122
glRasterPos2iv = _link_function('glRasterPos2iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1123
glRasterPos2sv = _link_function('glRasterPos2sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1125
glRasterPos3dv = _link_function('glRasterPos3dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1126
glRasterPos3fv = _link_function('glRasterPos3fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1127
glRasterPos3iv = _link_function('glRasterPos3iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1128
glRasterPos3sv = _link_function('glRasterPos3sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1130
glRasterPos4dv = _link_function('glRasterPos4dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1131
glRasterPos4fv = _link_function('glRasterPos4fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1132
glRasterPos4iv = _link_function('glRasterPos4iv', None, [POINTER(GLint)], None)
# /usr/include/GL/gl.h:1133
glRasterPos4sv = _link_function('glRasterPos4sv', None, [POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1136
glRectd = _link_function('glRectd', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1137
glRectf = _link_function('glRectf', None, [GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1138
glRecti = _link_function('glRecti', None, [GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1139
glRects = _link_function('glRects', None, [GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1142
glRectdv = _link_function('glRectdv', None, [POINTER(GLdouble), POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1143
glRectfv = _link_function('glRectfv', None, [POINTER(GLfloat), POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1144
glRectiv = _link_function('glRectiv', None, [POINTER(GLint), POINTER(GLint)], None)
# /usr/include/GL/gl.h:1145
glRectsv = _link_function('glRectsv', None, [POINTER(GLshort), POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1152
glVertexPointer = _link_function('glVertexPointer', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1155
glNormalPointer = _link_function('glNormalPointer', None, [GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1158
glColorPointer = _link_function('glColorPointer', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1161
glIndexPointer = _link_function('glIndexPointer', None, [GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1164
glTexCoordPointer = _link_function('glTexCoordPointer', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1167
glEdgeFlagPointer = _link_function('glEdgeFlagPointer', None, [GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1169
glGetPointerv = _link_function('glGetPointerv', None, [GLenum, POINTER(POINTER(GLvoid))], None)
# /usr/include/GL/gl.h:1171
glArrayElement = _link_function('glArrayElement', None, [GLint], None)
# /usr/include/GL/gl.h:1173
glDrawArrays = _link_function('glDrawArrays', None, [GLenum, GLint, GLsizei], None)
# /usr/include/GL/gl.h:1175
glDrawElements = _link_function('glDrawElements', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1178
glInterleavedArrays = _link_function('glInterleavedArrays', None, [GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1185
glShadeModel = _link_function('glShadeModel', None, [GLenum], None)
# /usr/include/GL/gl.h:1187
glLightf = _link_function('glLightf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1188
glLighti = _link_function('glLighti', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1189
glLightfv = _link_function('glLightfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1191
glLightiv = _link_function('glLightiv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1194
glGetLightfv = _link_function('glGetLightfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1196
glGetLightiv = _link_function('glGetLightiv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1199
glLightModelf = _link_function('glLightModelf', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1200
glLightModeli = _link_function('glLightModeli', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:1201
glLightModelfv = _link_function('glLightModelfv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1202
glLightModeliv = _link_function('glLightModeliv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1204
glMaterialf = _link_function('glMaterialf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1205
glMateriali = _link_function('glMateriali', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1206
glMaterialfv = _link_function('glMaterialfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1207
glMaterialiv = _link_function('glMaterialiv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1209
glGetMaterialfv = _link_function('glGetMaterialfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1210
glGetMaterialiv = _link_function('glGetMaterialiv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1212
glColorMaterial = _link_function('glColorMaterial', None, [GLenum, GLenum], None)
# /usr/include/GL/gl.h:1219
glPixelZoom = _link_function('glPixelZoom', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1221
glPixelStoref = _link_function('glPixelStoref', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1222
glPixelStorei = _link_function('glPixelStorei', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:1224
glPixelTransferf = _link_function('glPixelTransferf', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1225
glPixelTransferi = _link_function('glPixelTransferi', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:1227
glPixelMapfv = _link_function('glPixelMapfv', None, [GLenum, GLsizei, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1229
glPixelMapuiv = _link_function('glPixelMapuiv', None, [GLenum, GLsizei, POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1231
glPixelMapusv = _link_function('glPixelMapusv', None, [GLenum, GLsizei, POINTER(GLushort)], None)
# /usr/include/GL/gl.h:1234
glGetPixelMapfv = _link_function('glGetPixelMapfv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1235
glGetPixelMapuiv = _link_function('glGetPixelMapuiv', None, [GLenum, POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1236
glGetPixelMapusv = _link_function('glGetPixelMapusv', None, [GLenum, POINTER(GLushort)], None)
# /usr/include/GL/gl.h:1238
glBitmap = _link_function('glBitmap', None, [GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, POINTER(GLubyte)], None)
# /usr/include/GL/gl.h:1243
glReadPixels = _link_function('glReadPixels', None, [GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1248
glDrawPixels = _link_function('glDrawPixels', None, [GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1252
glCopyPixels = _link_function('glCopyPixels', None, [GLint, GLint, GLsizei, GLsizei, GLenum], None)
# /usr/include/GL/gl.h:1260
glStencilFunc = _link_function('glStencilFunc', None, [GLenum, GLint, GLuint], None)
# /usr/include/GL/gl.h:1262
glStencilMask = _link_function('glStencilMask', None, [GLuint], None)
# /usr/include/GL/gl.h:1264
glStencilOp = _link_function('glStencilOp', None, [GLenum, GLenum, GLenum], None)
# /usr/include/GL/gl.h:1266
glClearStencil = _link_function('glClearStencil', None, [GLint], None)
# /usr/include/GL/gl.h:1274
glTexGend = _link_function('glTexGend', None, [GLenum, GLenum, GLdouble], None)
# /usr/include/GL/gl.h:1275
glTexGenf = _link_function('glTexGenf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1276
glTexGeni = _link_function('glTexGeni', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1278
glTexGendv = _link_function('glTexGendv', None, [GLenum, GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1279
glTexGenfv = _link_function('glTexGenfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1280
glTexGeniv = _link_function('glTexGeniv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1282
glGetTexGendv = _link_function('glGetTexGendv', None, [GLenum, GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1283
glGetTexGenfv = _link_function('glGetTexGenfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1284
glGetTexGeniv = _link_function('glGetTexGeniv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1287
glTexEnvf = _link_function('glTexEnvf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1288
glTexEnvi = _link_function('glTexEnvi', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1290
glTexEnvfv = _link_function('glTexEnvfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1291
glTexEnviv = _link_function('glTexEnviv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1293
glGetTexEnvfv = _link_function('glGetTexEnvfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1294
glGetTexEnviv = _link_function('glGetTexEnviv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1297
glTexParameterf = _link_function('glTexParameterf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1298
glTexParameteri = _link_function('glTexParameteri', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1300
glTexParameterfv = _link_function('glTexParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1302
glTexParameteriv = _link_function('glTexParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1305
glGetTexParameterfv = _link_function('glGetTexParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1307
glGetTexParameteriv = _link_function('glGetTexParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1310
glGetTexLevelParameterfv = _link_function('glGetTexLevelParameterfv', None, [GLenum, GLint, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1312
glGetTexLevelParameteriv = _link_function('glGetTexLevelParameteriv', None, [GLenum, GLint, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1316
glTexImage1D = _link_function('glTexImage1D', None, [GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1322
glTexImage2D = _link_function('glTexImage2D', None, [GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1328
glGetTexImage = _link_function('glGetTexImage', None, [GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1335
glGenTextures = _link_function('glGenTextures', None, [GLsizei, POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1337
glDeleteTextures = _link_function('glDeleteTextures', None, [GLsizei, POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1339
glBindTexture = _link_function('glBindTexture', None, [GLenum, GLuint], None)
# /usr/include/GL/gl.h:1341
glPrioritizeTextures = _link_function('glPrioritizeTextures', None, [GLsizei, POINTER(GLuint), POINTER(GLclampf)], None)
# /usr/include/GL/gl.h:1345
glAreTexturesResident = _link_function('glAreTexturesResident', GLboolean, [GLsizei, POINTER(GLuint), POINTER(GLboolean)], None)
# /usr/include/GL/gl.h:1349
glIsTexture = _link_function('glIsTexture', GLboolean, [GLuint], None)
# /usr/include/GL/gl.h:1352
glTexSubImage1D = _link_function('glTexSubImage1D', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1358
glTexSubImage2D = _link_function('glTexSubImage2D', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1365
glCopyTexImage1D = _link_function('glCopyTexImage1D', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], None)
# /usr/include/GL/gl.h:1371
glCopyTexImage2D = _link_function('glCopyTexImage2D', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], None)
# /usr/include/GL/gl.h:1378
glCopyTexSubImage1D = _link_function('glCopyTexSubImage1D', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei], None)
# /usr/include/GL/gl.h:1383
glCopyTexSubImage2D = _link_function('glCopyTexSubImage2D', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], None)
# /usr/include/GL/gl.h:1393
glMap1d = _link_function('glMap1d', None, [GLenum, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1396
glMap1f = _link_function('glMap1f', None, [GLenum, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1400
glMap2d = _link_function('glMap2d', None, [GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1404
glMap2f = _link_function('glMap2f', None, [GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1409
glGetMapdv = _link_function('glGetMapdv', None, [GLenum, GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1410
glGetMapfv = _link_function('glGetMapfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1411
glGetMapiv = _link_function('glGetMapiv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1413
glEvalCoord1d = _link_function('glEvalCoord1d', None, [GLdouble], None)
# /usr/include/GL/gl.h:1414
glEvalCoord1f = _link_function('glEvalCoord1f', None, [GLfloat], None)
# /usr/include/GL/gl.h:1416
glEvalCoord1dv = _link_function('glEvalCoord1dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1417
glEvalCoord1fv = _link_function('glEvalCoord1fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1419
glEvalCoord2d = _link_function('glEvalCoord2d', None, [GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1420
glEvalCoord2f = _link_function('glEvalCoord2f', None, [GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1422
glEvalCoord2dv = _link_function('glEvalCoord2dv', None, [POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1423
glEvalCoord2fv = _link_function('glEvalCoord2fv', None, [POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1425
glMapGrid1d = _link_function('glMapGrid1d', None, [GLint, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1426
glMapGrid1f = _link_function('glMapGrid1f', None, [GLint, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1428
glMapGrid2d = _link_function('glMapGrid2d', None, [GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1430
glMapGrid2f = _link_function('glMapGrid2f', None, [GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1433
glEvalPoint1 = _link_function('glEvalPoint1', None, [GLint], None)
# /usr/include/GL/gl.h:1435
glEvalPoint2 = _link_function('glEvalPoint2', None, [GLint, GLint], None)
# /usr/include/GL/gl.h:1437
glEvalMesh1 = _link_function('glEvalMesh1', None, [GLenum, GLint, GLint], None)
# /usr/include/GL/gl.h:1439
glEvalMesh2 = _link_function('glEvalMesh2', None, [GLenum, GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1446
glFogf = _link_function('glFogf', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1448
glFogi = _link_function('glFogi', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:1450
glFogfv = _link_function('glFogfv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1452
glFogiv = _link_function('glFogiv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1459
glFeedbackBuffer = _link_function('glFeedbackBuffer', None, [GLsizei, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1461
glPassThrough = _link_function('glPassThrough', None, [GLfloat], None)
# /usr/include/GL/gl.h:1463
glSelectBuffer = _link_function('glSelectBuffer', None, [GLsizei, POINTER(GLuint)], None)
# /usr/include/GL/gl.h:1465
glInitNames = _link_function('glInitNames', None, [], None)
# /usr/include/GL/gl.h:1467
glLoadName = _link_function('glLoadName', None, [GLuint], None)
# /usr/include/GL/gl.h:1469
glPushName = _link_function('glPushName', None, [GLuint], None)
# /usr/include/GL/gl.h:1471
glPopName = _link_function('glPopName', None, [], None)
GL_RESCALE_NORMAL = 32826 # /usr/include/GL/gl.h:1479
GL_CLAMP_TO_EDGE = 33071 # /usr/include/GL/gl.h:1480
GL_MAX_ELEMENTS_VERTICES = 33000 # /usr/include/GL/gl.h:1481
GL_MAX_ELEMENTS_INDICES = 33001 # /usr/include/GL/gl.h:1482
GL_BGR = 32992 # /usr/include/GL/gl.h:1483
GL_BGRA = 32993 # /usr/include/GL/gl.h:1484
GL_UNSIGNED_BYTE_3_3_2 = 32818 # /usr/include/GL/gl.h:1485
GL_UNSIGNED_BYTE_2_3_3_REV = 33634 # /usr/include/GL/gl.h:1486
GL_UNSIGNED_SHORT_5_6_5 = 33635 # /usr/include/GL/gl.h:1487
GL_UNSIGNED_SHORT_5_6_5_REV = 33636 # /usr/include/GL/gl.h:1488
GL_UNSIGNED_SHORT_4_4_4_4 = 32819 # /usr/include/GL/gl.h:1489
GL_UNSIGNED_SHORT_4_4_4_4_REV = 33637 # /usr/include/GL/gl.h:1490
GL_UNSIGNED_SHORT_5_5_5_1 = 32820 # /usr/include/GL/gl.h:1491
GL_UNSIGNED_SHORT_1_5_5_5_REV = 33638 # /usr/include/GL/gl.h:1492
GL_UNSIGNED_INT_8_8_8_8 = 32821 # /usr/include/GL/gl.h:1493
GL_UNSIGNED_INT_8_8_8_8_REV = 33639 # /usr/include/GL/gl.h:1494
GL_UNSIGNED_INT_10_10_10_2 = 32822 # /usr/include/GL/gl.h:1495
GL_UNSIGNED_INT_2_10_10_10_REV = 33640 # /usr/include/GL/gl.h:1496
GL_LIGHT_MODEL_COLOR_CONTROL = 33272 # /usr/include/GL/gl.h:1497
GL_SINGLE_COLOR = 33273 # /usr/include/GL/gl.h:1498
GL_SEPARATE_SPECULAR_COLOR = 33274 # /usr/include/GL/gl.h:1499
GL_TEXTURE_MIN_LOD = 33082 # /usr/include/GL/gl.h:1500
GL_TEXTURE_MAX_LOD = 33083 # /usr/include/GL/gl.h:1501
GL_TEXTURE_BASE_LEVEL = 33084 # /usr/include/GL/gl.h:1502
GL_TEXTURE_MAX_LEVEL = 33085 # /usr/include/GL/gl.h:1503
GL_SMOOTH_POINT_SIZE_RANGE = 2834 # /usr/include/GL/gl.h:1504
GL_SMOOTH_POINT_SIZE_GRANULARITY = 2835 # /usr/include/GL/gl.h:1505
GL_SMOOTH_LINE_WIDTH_RANGE = 2850 # /usr/include/GL/gl.h:1506
GL_SMOOTH_LINE_WIDTH_GRANULARITY = 2851 # /usr/include/GL/gl.h:1507
GL_ALIASED_POINT_SIZE_RANGE = 33901 # /usr/include/GL/gl.h:1508
GL_ALIASED_LINE_WIDTH_RANGE = 33902 # /usr/include/GL/gl.h:1509
GL_PACK_SKIP_IMAGES = 32875 # /usr/include/GL/gl.h:1510
GL_PACK_IMAGE_HEIGHT = 32876 # /usr/include/GL/gl.h:1511
GL_UNPACK_SKIP_IMAGES = 32877 # /usr/include/GL/gl.h:1512
GL_UNPACK_IMAGE_HEIGHT = 32878 # /usr/include/GL/gl.h:1513
GL_TEXTURE_3D = 32879 # /usr/include/GL/gl.h:1514
GL_PROXY_TEXTURE_3D = 32880 # /usr/include/GL/gl.h:1515
GL_TEXTURE_DEPTH = 32881 # /usr/include/GL/gl.h:1516
GL_TEXTURE_WRAP_R = 32882 # /usr/include/GL/gl.h:1517
GL_MAX_3D_TEXTURE_SIZE = 32883 # /usr/include/GL/gl.h:1518
GL_TEXTURE_BINDING_3D = 32874 # /usr/include/GL/gl.h:1519
# /usr/include/GL/gl.h:1521
glDrawRangeElements = _link_function('glDrawRangeElements', None, [GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1524
glTexImage3D = _link_function('glTexImage3D', None, [GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1531
glTexSubImage3D = _link_function('glTexSubImage3D', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1538
glCopyTexSubImage3D = _link_function('glCopyTexSubImage3D', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], None)
PFNGLDRAWRANGEELEMENTSPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)) # /usr/include/GL/gl.h:1544
PFNGLTEXIMAGE3DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # /usr/include/GL/gl.h:1545
PFNGLTEXSUBIMAGE3DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # /usr/include/GL/gl.h:1546
PFNGLCOPYTEXSUBIMAGE3DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # /usr/include/GL/gl.h:1547
GL_CONSTANT_COLOR = 32769 # /usr/include/GL/gl.h:1554
GL_ONE_MINUS_CONSTANT_COLOR = 32770 # /usr/include/GL/gl.h:1555
GL_CONSTANT_ALPHA = 32771 # /usr/include/GL/gl.h:1556
GL_ONE_MINUS_CONSTANT_ALPHA = 32772 # /usr/include/GL/gl.h:1557
GL_COLOR_TABLE = 32976 # /usr/include/GL/gl.h:1558
GL_POST_CONVOLUTION_COLOR_TABLE = 32977 # /usr/include/GL/gl.h:1559
GL_POST_COLOR_MATRIX_COLOR_TABLE = 32978 # /usr/include/GL/gl.h:1560
GL_PROXY_COLOR_TABLE = 32979 # /usr/include/GL/gl.h:1561
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 32980 # /usr/include/GL/gl.h:1562
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 32981 # /usr/include/GL/gl.h:1563
GL_COLOR_TABLE_SCALE = 32982 # /usr/include/GL/gl.h:1564
GL_COLOR_TABLE_BIAS = 32983 # /usr/include/GL/gl.h:1565
GL_COLOR_TABLE_FORMAT = 32984 # /usr/include/GL/gl.h:1566
GL_COLOR_TABLE_WIDTH = 32985 # /usr/include/GL/gl.h:1567
GL_COLOR_TABLE_RED_SIZE = 32986 # /usr/include/GL/gl.h:1568
GL_COLOR_TABLE_GREEN_SIZE = 32987 # /usr/include/GL/gl.h:1569
GL_COLOR_TABLE_BLUE_SIZE = 32988 # /usr/include/GL/gl.h:1570
GL_COLOR_TABLE_ALPHA_SIZE = 32989 # /usr/include/GL/gl.h:1571
GL_COLOR_TABLE_LUMINANCE_SIZE = 32990 # /usr/include/GL/gl.h:1572
GL_COLOR_TABLE_INTENSITY_SIZE = 32991 # /usr/include/GL/gl.h:1573
GL_CONVOLUTION_1D = 32784 # /usr/include/GL/gl.h:1574
GL_CONVOLUTION_2D = 32785 # /usr/include/GL/gl.h:1575
GL_SEPARABLE_2D = 32786 # /usr/include/GL/gl.h:1576
GL_CONVOLUTION_BORDER_MODE = 32787 # /usr/include/GL/gl.h:1577
GL_CONVOLUTION_FILTER_SCALE = 32788 # /usr/include/GL/gl.h:1578
GL_CONVOLUTION_FILTER_BIAS = 32789 # /usr/include/GL/gl.h:1579
GL_REDUCE = 32790 # /usr/include/GL/gl.h:1580
GL_CONVOLUTION_FORMAT = 32791 # /usr/include/GL/gl.h:1581
GL_CONVOLUTION_WIDTH = 32792 # /usr/include/GL/gl.h:1582
GL_CONVOLUTION_HEIGHT = 32793 # /usr/include/GL/gl.h:1583
GL_MAX_CONVOLUTION_WIDTH = 32794 # /usr/include/GL/gl.h:1584
GL_MAX_CONVOLUTION_HEIGHT = 32795 # /usr/include/GL/gl.h:1585
GL_POST_CONVOLUTION_RED_SCALE = 32796 # /usr/include/GL/gl.h:1586
GL_POST_CONVOLUTION_GREEN_SCALE = 32797 # /usr/include/GL/gl.h:1587
GL_POST_CONVOLUTION_BLUE_SCALE = 32798 # /usr/include/GL/gl.h:1588
GL_POST_CONVOLUTION_ALPHA_SCALE = 32799 # /usr/include/GL/gl.h:1589
GL_POST_CONVOLUTION_RED_BIAS = 32800 # /usr/include/GL/gl.h:1590
GL_POST_CONVOLUTION_GREEN_BIAS = 32801 # /usr/include/GL/gl.h:1591
GL_POST_CONVOLUTION_BLUE_BIAS = 32802 # /usr/include/GL/gl.h:1592
GL_POST_CONVOLUTION_ALPHA_BIAS = 32803 # /usr/include/GL/gl.h:1593
GL_CONSTANT_BORDER = 33105 # /usr/include/GL/gl.h:1594
GL_REPLICATE_BORDER = 33107 # /usr/include/GL/gl.h:1595
GL_CONVOLUTION_BORDER_COLOR = 33108 # /usr/include/GL/gl.h:1596
GL_COLOR_MATRIX = 32945 # /usr/include/GL/gl.h:1597
GL_COLOR_MATRIX_STACK_DEPTH = 32946 # /usr/include/GL/gl.h:1598
GL_MAX_COLOR_MATRIX_STACK_DEPTH = 32947 # /usr/include/GL/gl.h:1599
GL_POST_COLOR_MATRIX_RED_SCALE = 32948 # /usr/include/GL/gl.h:1600
GL_POST_COLOR_MATRIX_GREEN_SCALE = 32949 # /usr/include/GL/gl.h:1601
GL_POST_COLOR_MATRIX_BLUE_SCALE = 32950 # /usr/include/GL/gl.h:1602
GL_POST_COLOR_MATRIX_ALPHA_SCALE = 32951 # /usr/include/GL/gl.h:1603
GL_POST_COLOR_MATRIX_RED_BIAS = 32952 # /usr/include/GL/gl.h:1604
GL_POST_COLOR_MATRIX_GREEN_BIAS = 32953 # /usr/include/GL/gl.h:1605
GL_POST_COLOR_MATRIX_BLUE_BIAS = 32954 # /usr/include/GL/gl.h:1606
GL_POST_COLOR_MATRIX_ALPHA_BIAS = 32955 # /usr/include/GL/gl.h:1607
GL_HISTOGRAM = 32804 # /usr/include/GL/gl.h:1608
GL_PROXY_HISTOGRAM = 32805 # /usr/include/GL/gl.h:1609
GL_HISTOGRAM_WIDTH = 32806 # /usr/include/GL/gl.h:1610
GL_HISTOGRAM_FORMAT = 32807 # /usr/include/GL/gl.h:1611
GL_HISTOGRAM_RED_SIZE = 32808 # /usr/include/GL/gl.h:1612
GL_HISTOGRAM_GREEN_SIZE = 32809 # /usr/include/GL/gl.h:1613
GL_HISTOGRAM_BLUE_SIZE = 32810 # /usr/include/GL/gl.h:1614
GL_HISTOGRAM_ALPHA_SIZE = 32811 # /usr/include/GL/gl.h:1615
GL_HISTOGRAM_LUMINANCE_SIZE = 32812 # /usr/include/GL/gl.h:1616
GL_HISTOGRAM_SINK = 32813 # /usr/include/GL/gl.h:1617
GL_MINMAX = 32814 # /usr/include/GL/gl.h:1618
GL_MINMAX_FORMAT = 32815 # /usr/include/GL/gl.h:1619
GL_MINMAX_SINK = 32816 # /usr/include/GL/gl.h:1620
GL_TABLE_TOO_LARGE = 32817 # /usr/include/GL/gl.h:1621
GL_BLEND_EQUATION = 32777 # /usr/include/GL/gl.h:1622
GL_MIN = 32775 # /usr/include/GL/gl.h:1623
GL_MAX = 32776 # /usr/include/GL/gl.h:1624
GL_FUNC_ADD = 32774 # /usr/include/GL/gl.h:1625
GL_FUNC_SUBTRACT = 32778 # /usr/include/GL/gl.h:1626
GL_FUNC_REVERSE_SUBTRACT = 32779 # /usr/include/GL/gl.h:1627
GL_BLEND_COLOR = 32773 # /usr/include/GL/gl.h:1628
# /usr/include/GL/gl.h:1631
glColorTable = _link_function('glColorTable', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1635
glColorSubTable = _link_function('glColorSubTable', None, [GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1640
glColorTableParameteriv = _link_function('glColorTableParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1643
glColorTableParameterfv = _link_function('glColorTableParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1646
glCopyColorSubTable = _link_function('glCopyColorSubTable', None, [GLenum, GLsizei, GLint, GLint, GLsizei], None)
# /usr/include/GL/gl.h:1649
glCopyColorTable = _link_function('glCopyColorTable', None, [GLenum, GLenum, GLint, GLint, GLsizei], None)
# /usr/include/GL/gl.h:1652
glGetColorTable = _link_function('glGetColorTable', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1655
glGetColorTableParameterfv = _link_function('glGetColorTableParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1658
glGetColorTableParameteriv = _link_function('glGetColorTableParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1661
glBlendEquation = _link_function('glBlendEquation', None, [GLenum], None)
# /usr/include/GL/gl.h:1663
glBlendColor = _link_function('glBlendColor', None, [GLclampf, GLclampf, GLclampf, GLclampf], None)
# /usr/include/GL/gl.h:1666
glHistogram = _link_function('glHistogram', None, [GLenum, GLsizei, GLenum, GLboolean], None)
# /usr/include/GL/gl.h:1669
glResetHistogram = _link_function('glResetHistogram', None, [GLenum], None)
# /usr/include/GL/gl.h:1671
glGetHistogram = _link_function('glGetHistogram', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1675
glGetHistogramParameterfv = _link_function('glGetHistogramParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1678
glGetHistogramParameteriv = _link_function('glGetHistogramParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1681
glMinmax = _link_function('glMinmax', None, [GLenum, GLenum, GLboolean], None)
# /usr/include/GL/gl.h:1684
glResetMinmax = _link_function('glResetMinmax', None, [GLenum], None)
# /usr/include/GL/gl.h:1686
glGetMinmax = _link_function('glGetMinmax', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1690
glGetMinmaxParameterfv = _link_function('glGetMinmaxParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1693
glGetMinmaxParameteriv = _link_function('glGetMinmaxParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1696
glConvolutionFilter1D = _link_function('glConvolutionFilter1D', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1700
glConvolutionFilter2D = _link_function('glConvolutionFilter2D', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1704
glConvolutionParameterf = _link_function('glConvolutionParameterf', None, [GLenum, GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1707
glConvolutionParameterfv = _link_function('glConvolutionParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1710
glConvolutionParameteri = _link_function('glConvolutionParameteri', None, [GLenum, GLenum, GLint], None)
# /usr/include/GL/gl.h:1713
glConvolutionParameteriv = _link_function('glConvolutionParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1716
glCopyConvolutionFilter1D = _link_function('glCopyConvolutionFilter1D', None, [GLenum, GLenum, GLint, GLint, GLsizei], None)
# /usr/include/GL/gl.h:1719
glCopyConvolutionFilter2D = _link_function('glCopyConvolutionFilter2D', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLsizei], None)
# /usr/include/GL/gl.h:1723
glGetConvolutionFilter = _link_function('glGetConvolutionFilter', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1726
glGetConvolutionParameterfv = _link_function('glGetConvolutionParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1729
glGetConvolutionParameteriv = _link_function('glGetConvolutionParameteriv', None, [GLenum, GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1732
glSeparableFilter2D = _link_function('glSeparableFilter2D', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1736
glGetSeparableFilter = _link_function('glGetSeparableFilter', None, [GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)], None)
PFNGLBLENDCOLORPROC = CFUNCTYPE(None, GLclampf, GLclampf, GLclampf, GLclampf) # /usr/include/GL/gl.h:1739
PFNGLBLENDEQUATIONPROC = CFUNCTYPE(None, GLenum) # /usr/include/GL/gl.h:1740
GL_TEXTURE0 = 33984 # /usr/include/GL/gl.h:1749
GL_TEXTURE1 = 33985 # /usr/include/GL/gl.h:1750
GL_TEXTURE2 = 33986 # /usr/include/GL/gl.h:1751
GL_TEXTURE3 = 33987 # /usr/include/GL/gl.h:1752
GL_TEXTURE4 = 33988 # /usr/include/GL/gl.h:1753
GL_TEXTURE5 = 33989 # /usr/include/GL/gl.h:1754
GL_TEXTURE6 = 33990 # /usr/include/GL/gl.h:1755
GL_TEXTURE7 = 33991 # /usr/include/GL/gl.h:1756
GL_TEXTURE8 = 33992 # /usr/include/GL/gl.h:1757
GL_TEXTURE9 = 33993 # /usr/include/GL/gl.h:1758
GL_TEXTURE10 = 33994 # /usr/include/GL/gl.h:1759
GL_TEXTURE11 = 33995 # /usr/include/GL/gl.h:1760
GL_TEXTURE12 = 33996 # /usr/include/GL/gl.h:1761
GL_TEXTURE13 = 33997 # /usr/include/GL/gl.h:1762
GL_TEXTURE14 = 33998 # /usr/include/GL/gl.h:1763
GL_TEXTURE15 = 33999 # /usr/include/GL/gl.h:1764
GL_TEXTURE16 = 34000 # /usr/include/GL/gl.h:1765
GL_TEXTURE17 = 34001 # /usr/include/GL/gl.h:1766
GL_TEXTURE18 = 34002 # /usr/include/GL/gl.h:1767
GL_TEXTURE19 = 34003 # /usr/include/GL/gl.h:1768
GL_TEXTURE20 = 34004 # /usr/include/GL/gl.h:1769
GL_TEXTURE21 = 34005 # /usr/include/GL/gl.h:1770
GL_TEXTURE22 = 34006 # /usr/include/GL/gl.h:1771
GL_TEXTURE23 = 34007 # /usr/include/GL/gl.h:1772
GL_TEXTURE24 = 34008 # /usr/include/GL/gl.h:1773
GL_TEXTURE25 = 34009 # /usr/include/GL/gl.h:1774
GL_TEXTURE26 = 34010 # /usr/include/GL/gl.h:1775
GL_TEXTURE27 = 34011 # /usr/include/GL/gl.h:1776
GL_TEXTURE28 = 34012 # /usr/include/GL/gl.h:1777
GL_TEXTURE29 = 34013 # /usr/include/GL/gl.h:1778
GL_TEXTURE30 = 34014 # /usr/include/GL/gl.h:1779
GL_TEXTURE31 = 34015 # /usr/include/GL/gl.h:1780
GL_ACTIVE_TEXTURE = 34016 # /usr/include/GL/gl.h:1781
GL_CLIENT_ACTIVE_TEXTURE = 34017 # /usr/include/GL/gl.h:1782
GL_MAX_TEXTURE_UNITS = 34018 # /usr/include/GL/gl.h:1783
GL_NORMAL_MAP = 34065 # /usr/include/GL/gl.h:1785
GL_REFLECTION_MAP = 34066 # /usr/include/GL/gl.h:1786
GL_TEXTURE_CUBE_MAP = 34067 # /usr/include/GL/gl.h:1787
GL_TEXTURE_BINDING_CUBE_MAP = 34068 # /usr/include/GL/gl.h:1788
GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069 # /usr/include/GL/gl.h:1789
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070 # /usr/include/GL/gl.h:1790
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071 # /usr/include/GL/gl.h:1791
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072 # /usr/include/GL/gl.h:1792
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073 # /usr/include/GL/gl.h:1793
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074 # /usr/include/GL/gl.h:1794
GL_PROXY_TEXTURE_CUBE_MAP = 34075 # /usr/include/GL/gl.h:1795
GL_MAX_CUBE_MAP_TEXTURE_SIZE = 34076 # /usr/include/GL/gl.h:1796
GL_COMPRESSED_ALPHA = 34025 # /usr/include/GL/gl.h:1798
GL_COMPRESSED_LUMINANCE = 34026 # /usr/include/GL/gl.h:1799
GL_COMPRESSED_LUMINANCE_ALPHA = 34027 # /usr/include/GL/gl.h:1800
GL_COMPRESSED_INTENSITY = 34028 # /usr/include/GL/gl.h:1801
GL_COMPRESSED_RGB = 34029 # /usr/include/GL/gl.h:1802
GL_COMPRESSED_RGBA = 34030 # /usr/include/GL/gl.h:1803
GL_TEXTURE_COMPRESSION_HINT = 34031 # /usr/include/GL/gl.h:1804
GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 34464 # /usr/include/GL/gl.h:1805
GL_TEXTURE_COMPRESSED = 34465 # /usr/include/GL/gl.h:1806
GL_NUM_COMPRESSED_TEXTURE_FORMATS = 34466 # /usr/include/GL/gl.h:1807
GL_COMPRESSED_TEXTURE_FORMATS = 34467 # /usr/include/GL/gl.h:1808
GL_MULTISAMPLE = 32925 # /usr/include/GL/gl.h:1810
GL_SAMPLE_ALPHA_TO_COVERAGE = 32926 # /usr/include/GL/gl.h:1811
GL_SAMPLE_ALPHA_TO_ONE = 32927 # /usr/include/GL/gl.h:1812
GL_SAMPLE_COVERAGE = 32928 # /usr/include/GL/gl.h:1813
GL_SAMPLE_BUFFERS = 32936 # /usr/include/GL/gl.h:1814
GL_SAMPLES = 32937 # /usr/include/GL/gl.h:1815
GL_SAMPLE_COVERAGE_VALUE = 32938 # /usr/include/GL/gl.h:1816
GL_SAMPLE_COVERAGE_INVERT = 32939 # /usr/include/GL/gl.h:1817
GL_MULTISAMPLE_BIT = 536870912 # /usr/include/GL/gl.h:1818
GL_TRANSPOSE_MODELVIEW_MATRIX = 34019 # /usr/include/GL/gl.h:1820
GL_TRANSPOSE_PROJECTION_MATRIX = 34020 # /usr/include/GL/gl.h:1821
GL_TRANSPOSE_TEXTURE_MATRIX = 34021 # /usr/include/GL/gl.h:1822
GL_TRANSPOSE_COLOR_MATRIX = 34022 # /usr/include/GL/gl.h:1823
GL_COMBINE = 34160 # /usr/include/GL/gl.h:1825
GL_COMBINE_RGB = 34161 # /usr/include/GL/gl.h:1826
GL_COMBINE_ALPHA = 34162 # /usr/include/GL/gl.h:1827
GL_SOURCE0_RGB = 34176 # /usr/include/GL/gl.h:1828
GL_SOURCE1_RGB = 34177 # /usr/include/GL/gl.h:1829
GL_SOURCE2_RGB = 34178 # /usr/include/GL/gl.h:1830
GL_SOURCE0_ALPHA = 34184 # /usr/include/GL/gl.h:1831
GL_SOURCE1_ALPHA = 34185 # /usr/include/GL/gl.h:1832
GL_SOURCE2_ALPHA = 34186 # /usr/include/GL/gl.h:1833
GL_OPERAND0_RGB = 34192 # /usr/include/GL/gl.h:1834
GL_OPERAND1_RGB = 34193 # /usr/include/GL/gl.h:1835
GL_OPERAND2_RGB = 34194 # /usr/include/GL/gl.h:1836
GL_OPERAND0_ALPHA = 34200 # /usr/include/GL/gl.h:1837
GL_OPERAND1_ALPHA = 34201 # /usr/include/GL/gl.h:1838
GL_OPERAND2_ALPHA = 34202 # /usr/include/GL/gl.h:1839
GL_RGB_SCALE = 34163 # /usr/include/GL/gl.h:1840
GL_ADD_SIGNED = 34164 # /usr/include/GL/gl.h:1841
GL_INTERPOLATE = 34165 # /usr/include/GL/gl.h:1842
GL_SUBTRACT = 34023 # /usr/include/GL/gl.h:1843
GL_CONSTANT = 34166 # /usr/include/GL/gl.h:1844
GL_PRIMARY_COLOR = 34167 # /usr/include/GL/gl.h:1845
GL_PREVIOUS = 34168 # /usr/include/GL/gl.h:1846
GL_DOT3_RGB = 34478 # /usr/include/GL/gl.h:1848
GL_DOT3_RGBA = 34479 # /usr/include/GL/gl.h:1849
GL_CLAMP_TO_BORDER = 33069 # /usr/include/GL/gl.h:1851
# /usr/include/GL/gl.h:1853
glActiveTexture = _link_function('glActiveTexture', None, [GLenum], None)
# /usr/include/GL/gl.h:1855
glClientActiveTexture = _link_function('glClientActiveTexture', None, [GLenum], None)
# /usr/include/GL/gl.h:1857
glCompressedTexImage1D = _link_function('glCompressedTexImage1D', None, [GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1859
glCompressedTexImage2D = _link_function('glCompressedTexImage2D', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1861
glCompressedTexImage3D = _link_function('glCompressedTexImage3D', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1863
glCompressedTexSubImage1D = _link_function('glCompressedTexSubImage1D', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1865
glCompressedTexSubImage2D = _link_function('glCompressedTexSubImage2D', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1867
glCompressedTexSubImage3D = _link_function('glCompressedTexSubImage3D', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1869
glGetCompressedTexImage = _link_function('glGetCompressedTexImage', None, [GLenum, GLint, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:1871
glMultiTexCoord1d = _link_function('glMultiTexCoord1d', None, [GLenum, GLdouble], None)
# /usr/include/GL/gl.h:1873
glMultiTexCoord1dv = _link_function('glMultiTexCoord1dv', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1875
glMultiTexCoord1f = _link_function('glMultiTexCoord1f', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:1877
glMultiTexCoord1fv = _link_function('glMultiTexCoord1fv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1879
glMultiTexCoord1i = _link_function('glMultiTexCoord1i', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:1881
glMultiTexCoord1iv = _link_function('glMultiTexCoord1iv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1883
glMultiTexCoord1s = _link_function('glMultiTexCoord1s', None, [GLenum, GLshort], None)
# /usr/include/GL/gl.h:1885
glMultiTexCoord1sv = _link_function('glMultiTexCoord1sv', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1887
glMultiTexCoord2d = _link_function('glMultiTexCoord2d', None, [GLenum, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1889
glMultiTexCoord2dv = _link_function('glMultiTexCoord2dv', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1891
glMultiTexCoord2f = _link_function('glMultiTexCoord2f', None, [GLenum, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1893
glMultiTexCoord2fv = _link_function('glMultiTexCoord2fv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1895
glMultiTexCoord2i = _link_function('glMultiTexCoord2i', None, [GLenum, GLint, GLint], None)
# /usr/include/GL/gl.h:1897
glMultiTexCoord2iv = _link_function('glMultiTexCoord2iv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1899
glMultiTexCoord2s = _link_function('glMultiTexCoord2s', None, [GLenum, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1901
glMultiTexCoord2sv = _link_function('glMultiTexCoord2sv', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1903
glMultiTexCoord3d = _link_function('glMultiTexCoord3d', None, [GLenum, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1905
glMultiTexCoord3dv = _link_function('glMultiTexCoord3dv', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1907
glMultiTexCoord3f = _link_function('glMultiTexCoord3f', None, [GLenum, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1909
glMultiTexCoord3fv = _link_function('glMultiTexCoord3fv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1911
glMultiTexCoord3i = _link_function('glMultiTexCoord3i', None, [GLenum, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1913
glMultiTexCoord3iv = _link_function('glMultiTexCoord3iv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1915
glMultiTexCoord3s = _link_function('glMultiTexCoord3s', None, [GLenum, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1917
glMultiTexCoord3sv = _link_function('glMultiTexCoord3sv', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1919
glMultiTexCoord4d = _link_function('glMultiTexCoord4d', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:1921
glMultiTexCoord4dv = _link_function('glMultiTexCoord4dv', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:1923
glMultiTexCoord4f = _link_function('glMultiTexCoord4f', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:1925
glMultiTexCoord4fv = _link_function('glMultiTexCoord4fv', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:1927
glMultiTexCoord4i = _link_function('glMultiTexCoord4i', None, [GLenum, GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:1929
glMultiTexCoord4iv = _link_function('glMultiTexCoord4iv', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:1931
glMultiTexCoord4s = _link_function('glMultiTexCoord4s', None, [GLenum, GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:1933
glMultiTexCoord4sv = _link_function('glMultiTexCoord4sv', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:1936
glLoadTransposeMatrixd = _link_function('glLoadTransposeMatrixd', None, [GLdouble * 16], None)
# /usr/include/GL/gl.h:1938
glLoadTransposeMatrixf = _link_function('glLoadTransposeMatrixf', None, [GLfloat * 16], None)
# /usr/include/GL/gl.h:1940
glMultTransposeMatrixd = _link_function('glMultTransposeMatrixd', None, [GLdouble * 16], None)
# /usr/include/GL/gl.h:1942
glMultTransposeMatrixf = _link_function('glMultTransposeMatrixf', None, [GLfloat * 16], None)
# /usr/include/GL/gl.h:1944
glSampleCoverage = _link_function('glSampleCoverage', None, [GLclampf, GLboolean], None)
PFNGLACTIVETEXTUREPROC = CFUNCTYPE(None, GLenum) # /usr/include/GL/gl.h:1947
PFNGLSAMPLECOVERAGEPROC = CFUNCTYPE(None, GLclampf, GLboolean) # /usr/include/GL/gl.h:1948
PFNGLCOMPRESSEDTEXIMAGE3DPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1949
PFNGLCOMPRESSEDTEXIMAGE2DPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1950
PFNGLCOMPRESSEDTEXIMAGE1DPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1951
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1952
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1953
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # /usr/include/GL/gl.h:1954
PFNGLGETCOMPRESSEDTEXIMAGEPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLvoid)) # /usr/include/GL/gl.h:1955
GL_ARB_multitexture = 1 # /usr/include/GL/gl.h:1963
GL_TEXTURE0_ARB = 33984 # /usr/include/GL/gl.h:1965
GL_TEXTURE1_ARB = 33985 # /usr/include/GL/gl.h:1966
GL_TEXTURE2_ARB = 33986 # /usr/include/GL/gl.h:1967
GL_TEXTURE3_ARB = 33987 # /usr/include/GL/gl.h:1968
GL_TEXTURE4_ARB = 33988 # /usr/include/GL/gl.h:1969
GL_TEXTURE5_ARB = 33989 # /usr/include/GL/gl.h:1970
GL_TEXTURE6_ARB = 33990 # /usr/include/GL/gl.h:1971
GL_TEXTURE7_ARB = 33991 # /usr/include/GL/gl.h:1972
GL_TEXTURE8_ARB = 33992 # /usr/include/GL/gl.h:1973
GL_TEXTURE9_ARB = 33993 # /usr/include/GL/gl.h:1974
GL_TEXTURE10_ARB = 33994 # /usr/include/GL/gl.h:1975
GL_TEXTURE11_ARB = 33995 # /usr/include/GL/gl.h:1976
GL_TEXTURE12_ARB = 33996 # /usr/include/GL/gl.h:1977
GL_TEXTURE13_ARB = 33997 # /usr/include/GL/gl.h:1978
GL_TEXTURE14_ARB = 33998 # /usr/include/GL/gl.h:1979
GL_TEXTURE15_ARB = 33999 # /usr/include/GL/gl.h:1980
GL_TEXTURE16_ARB = 34000 # /usr/include/GL/gl.h:1981
GL_TEXTURE17_ARB = 34001 # /usr/include/GL/gl.h:1982
GL_TEXTURE18_ARB = 34002 # /usr/include/GL/gl.h:1983
GL_TEXTURE19_ARB = 34003 # /usr/include/GL/gl.h:1984
GL_TEXTURE20_ARB = 34004 # /usr/include/GL/gl.h:1985
GL_TEXTURE21_ARB = 34005 # /usr/include/GL/gl.h:1986
GL_TEXTURE22_ARB = 34006 # /usr/include/GL/gl.h:1987
GL_TEXTURE23_ARB = 34007 # /usr/include/GL/gl.h:1988
GL_TEXTURE24_ARB = 34008 # /usr/include/GL/gl.h:1989
GL_TEXTURE25_ARB = 34009 # /usr/include/GL/gl.h:1990
GL_TEXTURE26_ARB = 34010 # /usr/include/GL/gl.h:1991
GL_TEXTURE27_ARB = 34011 # /usr/include/GL/gl.h:1992
GL_TEXTURE28_ARB = 34012 # /usr/include/GL/gl.h:1993
GL_TEXTURE29_ARB = 34013 # /usr/include/GL/gl.h:1994
GL_TEXTURE30_ARB = 34014 # /usr/include/GL/gl.h:1995
GL_TEXTURE31_ARB = 34015 # /usr/include/GL/gl.h:1996
GL_ACTIVE_TEXTURE_ARB = 34016 # /usr/include/GL/gl.h:1997
GL_CLIENT_ACTIVE_TEXTURE_ARB = 34017 # /usr/include/GL/gl.h:1998
GL_MAX_TEXTURE_UNITS_ARB = 34018 # /usr/include/GL/gl.h:1999
# /usr/include/GL/gl.h:2001
glActiveTextureARB = _link_function('glActiveTextureARB', None, [GLenum], None)
# /usr/include/GL/gl.h:2002
glClientActiveTextureARB = _link_function('glClientActiveTextureARB', None, [GLenum], None)
# /usr/include/GL/gl.h:2003
glMultiTexCoord1dARB = _link_function('glMultiTexCoord1dARB', None, [GLenum, GLdouble], None)
# /usr/include/GL/gl.h:2004
glMultiTexCoord1dvARB = _link_function('glMultiTexCoord1dvARB', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:2005
glMultiTexCoord1fARB = _link_function('glMultiTexCoord1fARB', None, [GLenum, GLfloat], None)
# /usr/include/GL/gl.h:2006
glMultiTexCoord1fvARB = _link_function('glMultiTexCoord1fvARB', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:2007
glMultiTexCoord1iARB = _link_function('glMultiTexCoord1iARB', None, [GLenum, GLint], None)
# /usr/include/GL/gl.h:2008
glMultiTexCoord1ivARB = _link_function('glMultiTexCoord1ivARB', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:2009
glMultiTexCoord1sARB = _link_function('glMultiTexCoord1sARB', None, [GLenum, GLshort], None)
# /usr/include/GL/gl.h:2010
glMultiTexCoord1svARB = _link_function('glMultiTexCoord1svARB', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:2011
glMultiTexCoord2dARB = _link_function('glMultiTexCoord2dARB', None, [GLenum, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:2012
glMultiTexCoord2dvARB = _link_function('glMultiTexCoord2dvARB', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:2013
glMultiTexCoord2fARB = _link_function('glMultiTexCoord2fARB', None, [GLenum, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:2014
glMultiTexCoord2fvARB = _link_function('glMultiTexCoord2fvARB', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:2015
glMultiTexCoord2iARB = _link_function('glMultiTexCoord2iARB', None, [GLenum, GLint, GLint], None)
# /usr/include/GL/gl.h:2016
glMultiTexCoord2ivARB = _link_function('glMultiTexCoord2ivARB', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:2017
glMultiTexCoord2sARB = _link_function('glMultiTexCoord2sARB', None, [GLenum, GLshort, GLshort], None)
# /usr/include/GL/gl.h:2018
glMultiTexCoord2svARB = _link_function('glMultiTexCoord2svARB', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:2019
glMultiTexCoord3dARB = _link_function('glMultiTexCoord3dARB', None, [GLenum, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:2020
glMultiTexCoord3dvARB = _link_function('glMultiTexCoord3dvARB', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:2021
glMultiTexCoord3fARB = _link_function('glMultiTexCoord3fARB', None, [GLenum, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:2022
glMultiTexCoord3fvARB = _link_function('glMultiTexCoord3fvARB', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:2023
glMultiTexCoord3iARB = _link_function('glMultiTexCoord3iARB', None, [GLenum, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:2024
glMultiTexCoord3ivARB = _link_function('glMultiTexCoord3ivARB', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:2025
glMultiTexCoord3sARB = _link_function('glMultiTexCoord3sARB', None, [GLenum, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:2026
glMultiTexCoord3svARB = _link_function('glMultiTexCoord3svARB', None, [GLenum, POINTER(GLshort)], None)
# /usr/include/GL/gl.h:2027
glMultiTexCoord4dARB = _link_function('glMultiTexCoord4dARB', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/gl.h:2028
glMultiTexCoord4dvARB = _link_function('glMultiTexCoord4dvARB', None, [GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/gl.h:2029
glMultiTexCoord4fARB = _link_function('glMultiTexCoord4fARB', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], None)
# /usr/include/GL/gl.h:2030
glMultiTexCoord4fvARB = _link_function('glMultiTexCoord4fvARB', None, [GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/gl.h:2031
glMultiTexCoord4iARB = _link_function('glMultiTexCoord4iARB', None, [GLenum, GLint, GLint, GLint, GLint], None)
# /usr/include/GL/gl.h:2032
glMultiTexCoord4ivARB = _link_function('glMultiTexCoord4ivARB', None, [GLenum, POINTER(GLint)], None)
# /usr/include/GL/gl.h:2033
glMultiTexCoord4sARB = _link_function('glMultiTexCoord4sARB', None, [GLenum, GLshort, GLshort, GLshort, GLshort], None)
# /usr/include/GL/gl.h:2034
glMultiTexCoord4svARB = _link_function('glMultiTexCoord4svARB', None, [GLenum, POINTER(GLshort)], None)
PFNGLACTIVETEXTUREARBPROC = CFUNCTYPE(None, GLenum) # /usr/include/GL/gl.h:2036
PFNGLCLIENTACTIVETEXTUREARBPROC = CFUNCTYPE(None, GLenum) # /usr/include/GL/gl.h:2037
PFNGLMULTITEXCOORD1DARBPROC = CFUNCTYPE(None, GLenum, GLdouble) # /usr/include/GL/gl.h:2038
PFNGLMULTITEXCOORD1DVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # /usr/include/GL/gl.h:2039
PFNGLMULTITEXCOORD1FARBPROC = CFUNCTYPE(None, GLenum, GLfloat) # /usr/include/GL/gl.h:2040
PFNGLMULTITEXCOORD1FVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # /usr/include/GL/gl.h:2041
PFNGLMULTITEXCOORD1IARBPROC = CFUNCTYPE(None, GLenum, GLint) # /usr/include/GL/gl.h:2042
PFNGLMULTITEXCOORD1IVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # /usr/include/GL/gl.h:2043
PFNGLMULTITEXCOORD1SARBPROC = CFUNCTYPE(None, GLenum, GLshort) # /usr/include/GL/gl.h:2044
PFNGLMULTITEXCOORD1SVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # /usr/include/GL/gl.h:2045
PFNGLMULTITEXCOORD2DARBPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble) # /usr/include/GL/gl.h:2046
PFNGLMULTITEXCOORD2DVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # /usr/include/GL/gl.h:2047
PFNGLMULTITEXCOORD2FARBPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat) # /usr/include/GL/gl.h:2048
PFNGLMULTITEXCOORD2FVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # /usr/include/GL/gl.h:2049
PFNGLMULTITEXCOORD2IARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint) # /usr/include/GL/gl.h:2050
PFNGLMULTITEXCOORD2IVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # /usr/include/GL/gl.h:2051
PFNGLMULTITEXCOORD2SARBPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort) # /usr/include/GL/gl.h:2052
PFNGLMULTITEXCOORD2SVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # /usr/include/GL/gl.h:2053
PFNGLMULTITEXCOORD3DARBPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # /usr/include/GL/gl.h:2054
PFNGLMULTITEXCOORD3DVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # /usr/include/GL/gl.h:2055
PFNGLMULTITEXCOORD3FARBPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # /usr/include/GL/gl.h:2056
PFNGLMULTITEXCOORD3FVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # /usr/include/GL/gl.h:2057
PFNGLMULTITEXCOORD3IARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # /usr/include/GL/gl.h:2058
PFNGLMULTITEXCOORD3IVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # /usr/include/GL/gl.h:2059
PFNGLMULTITEXCOORD3SARBPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # /usr/include/GL/gl.h:2060
PFNGLMULTITEXCOORD3SVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # /usr/include/GL/gl.h:2061
PFNGLMULTITEXCOORD4DARBPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # /usr/include/GL/gl.h:2062
PFNGLMULTITEXCOORD4DVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # /usr/include/GL/gl.h:2063
PFNGLMULTITEXCOORD4FARBPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # /usr/include/GL/gl.h:2064
PFNGLMULTITEXCOORD4FVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # /usr/include/GL/gl.h:2065
PFNGLMULTITEXCOORD4IARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint) # /usr/include/GL/gl.h:2066
PFNGLMULTITEXCOORD4IVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # /usr/include/GL/gl.h:2067
PFNGLMULTITEXCOORD4SARBPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort, GLshort) # /usr/include/GL/gl.h:2068
PFNGLMULTITEXCOORD4SVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # /usr/include/GL/gl.h:2069
GL_MESA_shader_debug = 1 # /usr/include/GL/gl.h:2094
GL_DEBUG_OBJECT_MESA = 34649 # /usr/include/GL/gl.h:2096
GL_DEBUG_PRINT_MESA = 34650 # /usr/include/GL/gl.h:2097
GL_DEBUG_ASSERT_MESA = 34651 # /usr/include/GL/gl.h:2098
GLhandleARB = c_uint # /usr/include/GL/glext.h:5340
# /usr/include/GL/gl.h:2100
glCreateDebugObjectMESA = _link_function('glCreateDebugObjectMESA', GLhandleARB, [], None)
# /usr/include/GL/gl.h:2101
glClearDebugLogMESA = _link_function('glClearDebugLogMESA', None, [GLhandleARB, GLenum, GLenum], None)
GLcharARB = c_char # /usr/include/GL/glext.h:5339
# /usr/include/GL/gl.h:2102
glGetDebugLogMESA = _link_function('glGetDebugLogMESA', None, [GLhandleARB, GLenum, GLenum, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)], None)
# /usr/include/GL/gl.h:2104
glGetDebugLogLengthMESA = _link_function('glGetDebugLogLengthMESA', GLsizei, [GLhandleARB, GLenum, GLenum], None)
GL_MESA_packed_depth_stencil = 1 # /usr/include/GL/gl.h:2116
GL_DEPTH_STENCIL_MESA = 34640 # /usr/include/GL/gl.h:2118
GL_UNSIGNED_INT_24_8_MESA = 34641 # /usr/include/GL/gl.h:2119
GL_UNSIGNED_INT_8_24_REV_MESA = 34642 # /usr/include/GL/gl.h:2120
GL_UNSIGNED_SHORT_15_1_MESA = 34643 # /usr/include/GL/gl.h:2121
GL_UNSIGNED_SHORT_1_15_REV_MESA = 34644 # /usr/include/GL/gl.h:2122
GL_MESA_program_debug = 1 # /usr/include/GL/gl.h:2128
GL_FRAGMENT_PROGRAM_POSITION_MESA = 35760 # /usr/include/GL/gl.h:2130
GL_FRAGMENT_PROGRAM_CALLBACK_MESA = 35761 # /usr/include/GL/gl.h:2131
GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA = 35762 # /usr/include/GL/gl.h:2132
GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA = 35763 # /usr/include/GL/gl.h:2133
GL_VERTEX_PROGRAM_POSITION_MESA = 35764 # /usr/include/GL/gl.h:2134
GL_VERTEX_PROGRAM_CALLBACK_MESA = 35765 # /usr/include/GL/gl.h:2135
GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA = 35766 # /usr/include/GL/gl.h:2136
GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA = 35767 # /usr/include/GL/gl.h:2137
GLprogramcallbackMESA = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # /usr/include/GL/gl.h:2139
# /usr/include/GL/gl.h:2141
glProgramCallbackMESA = _link_function('glProgramCallbackMESA', None, [GLenum, GLprogramcallbackMESA, POINTER(GLvoid)], None)
# /usr/include/GL/gl.h:2143
glGetProgramRegisterfvMESA = _link_function('glGetProgramRegisterfvMESA', None, [GLenum, GLsizei, POINTER(GLubyte), POINTER(GLfloat)], None)
GL_MESA_texture_array = 1 # /usr/include/GL/gl.h:2149
GL_ATI_blend_equation_separate = 1 # /usr/include/GL/gl.h:2182
GL_ALPHA_BLEND_EQUATION_ATI = 34877 # /usr/include/GL/gl.h:2184
# /usr/include/GL/gl.h:2186
glBlendEquationSeparateATI = _link_function('glBlendEquationSeparateATI', None, [GLenum, GLenum], None)
PFNGLBLENDEQUATIONSEPARATEATIPROC = CFUNCTYPE(None, GLenum, GLenum) # /usr/include/GL/gl.h:2187
GLeglImageOES = POINTER(None) # /usr/include/GL/gl.h:2194
GL_OES_EGL_image = 1 # /usr/include/GL/gl.h:2198
PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = CFUNCTYPE(None, GLenum, GLeglImageOES) # /usr/include/GL/gl.h:2203
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC = CFUNCTYPE(None, GLenum, GLeglImageOES) # /usr/include/GL/gl.h:2204
__all__ = ['GL_VERSION_1_1', 'GL_VERSION_1_2', 'GL_VERSION_1_3',
'GL_ARB_imaging', 'GLenum', 'GLboolean', 'GLbitfield', 'GLvoid', 'GLbyte',
'GLshort', 'GLint', 'GLubyte', 'GLushort', 'GLuint', 'GLsizei', 'GLfloat',
'GLclampf', 'GLdouble', 'GLclampd', 'GL_FALSE', 'GL_TRUE', 'GL_BYTE',
'GL_UNSIGNED_BYTE', 'GL_SHORT', 'GL_UNSIGNED_SHORT', 'GL_INT',
'GL_UNSIGNED_INT', 'GL_FLOAT', 'GL_2_BYTES', 'GL_3_BYTES', 'GL_4_BYTES',
'GL_DOUBLE', 'GL_POINTS', 'GL_LINES', 'GL_LINE_LOOP', 'GL_LINE_STRIP',
'GL_TRIANGLES', 'GL_TRIANGLE_STRIP', 'GL_TRIANGLE_FAN', 'GL_QUADS',
'GL_QUAD_STRIP', 'GL_POLYGON', 'GL_VERTEX_ARRAY', 'GL_NORMAL_ARRAY',
'GL_COLOR_ARRAY', 'GL_INDEX_ARRAY', 'GL_TEXTURE_COORD_ARRAY',
'GL_EDGE_FLAG_ARRAY', 'GL_VERTEX_ARRAY_SIZE', 'GL_VERTEX_ARRAY_TYPE',
'GL_VERTEX_ARRAY_STRIDE', 'GL_NORMAL_ARRAY_TYPE', 'GL_NORMAL_ARRAY_STRIDE',
'GL_COLOR_ARRAY_SIZE', 'GL_COLOR_ARRAY_TYPE', 'GL_COLOR_ARRAY_STRIDE',
'GL_INDEX_ARRAY_TYPE', 'GL_INDEX_ARRAY_STRIDE', 'GL_TEXTURE_COORD_ARRAY_SIZE',
'GL_TEXTURE_COORD_ARRAY_TYPE', 'GL_TEXTURE_COORD_ARRAY_STRIDE',
'GL_EDGE_FLAG_ARRAY_STRIDE', 'GL_VERTEX_ARRAY_POINTER',
'GL_NORMAL_ARRAY_POINTER', 'GL_COLOR_ARRAY_POINTER', 'GL_INDEX_ARRAY_POINTER',
'GL_TEXTURE_COORD_ARRAY_POINTER', 'GL_EDGE_FLAG_ARRAY_POINTER', 'GL_V2F',
'GL_V3F', 'GL_C4UB_V2F', 'GL_C4UB_V3F', 'GL_C3F_V3F', 'GL_N3F_V3F',
'GL_C4F_N3F_V3F', 'GL_T2F_V3F', 'GL_T4F_V4F', 'GL_T2F_C4UB_V3F',
'GL_T2F_C3F_V3F', 'GL_T2F_N3F_V3F', 'GL_T2F_C4F_N3F_V3F',
'GL_T4F_C4F_N3F_V4F', 'GL_MATRIX_MODE', 'GL_MODELVIEW', 'GL_PROJECTION',
'GL_TEXTURE', 'GL_POINT_SMOOTH', 'GL_POINT_SIZE', 'GL_POINT_SIZE_GRANULARITY',
'GL_POINT_SIZE_RANGE', 'GL_LINE_SMOOTH', 'GL_LINE_STIPPLE',
'GL_LINE_STIPPLE_PATTERN', 'GL_LINE_STIPPLE_REPEAT', 'GL_LINE_WIDTH',
'GL_LINE_WIDTH_GRANULARITY', 'GL_LINE_WIDTH_RANGE', 'GL_POINT', 'GL_LINE',
'GL_FILL', 'GL_CW', 'GL_CCW', 'GL_FRONT', 'GL_BACK', 'GL_POLYGON_MODE',
'GL_POLYGON_SMOOTH', 'GL_POLYGON_STIPPLE', 'GL_EDGE_FLAG', 'GL_CULL_FACE',
'GL_CULL_FACE_MODE', 'GL_FRONT_FACE', 'GL_POLYGON_OFFSET_FACTOR',
'GL_POLYGON_OFFSET_UNITS', 'GL_POLYGON_OFFSET_POINT',
'GL_POLYGON_OFFSET_LINE', 'GL_POLYGON_OFFSET_FILL', 'GL_COMPILE',
'GL_COMPILE_AND_EXECUTE', 'GL_LIST_BASE', 'GL_LIST_INDEX', 'GL_LIST_MODE',
'GL_NEVER', 'GL_LESS', 'GL_EQUAL', 'GL_LEQUAL', 'GL_GREATER', 'GL_NOTEQUAL',
'GL_GEQUAL', 'GL_ALWAYS', 'GL_DEPTH_TEST', 'GL_DEPTH_BITS',
'GL_DEPTH_CLEAR_VALUE', 'GL_DEPTH_FUNC', 'GL_DEPTH_RANGE',
'GL_DEPTH_WRITEMASK', 'GL_DEPTH_COMPONENT', 'GL_LIGHTING', 'GL_LIGHT0',
'GL_LIGHT1', 'GL_LIGHT2', 'GL_LIGHT3', 'GL_LIGHT4', 'GL_LIGHT5', 'GL_LIGHT6',
'GL_LIGHT7', 'GL_SPOT_EXPONENT', 'GL_SPOT_CUTOFF', 'GL_CONSTANT_ATTENUATION',
'GL_LINEAR_ATTENUATION', 'GL_QUADRATIC_ATTENUATION', 'GL_AMBIENT',
'GL_DIFFUSE', 'GL_SPECULAR', 'GL_SHININESS', 'GL_EMISSION', 'GL_POSITION',
'GL_SPOT_DIRECTION', 'GL_AMBIENT_AND_DIFFUSE', 'GL_COLOR_INDEXES',
'GL_LIGHT_MODEL_TWO_SIDE', 'GL_LIGHT_MODEL_LOCAL_VIEWER',
'GL_LIGHT_MODEL_AMBIENT', 'GL_FRONT_AND_BACK', 'GL_SHADE_MODEL', 'GL_FLAT',
'GL_SMOOTH', 'GL_COLOR_MATERIAL', 'GL_COLOR_MATERIAL_FACE',
'GL_COLOR_MATERIAL_PARAMETER', 'GL_NORMALIZE', 'GL_CLIP_PLANE0',
'GL_CLIP_PLANE1', 'GL_CLIP_PLANE2', 'GL_CLIP_PLANE3', 'GL_CLIP_PLANE4',
'GL_CLIP_PLANE5', 'GL_ACCUM_RED_BITS', 'GL_ACCUM_GREEN_BITS',
'GL_ACCUM_BLUE_BITS', 'GL_ACCUM_ALPHA_BITS', 'GL_ACCUM_CLEAR_VALUE',
'GL_ACCUM', 'GL_ADD', 'GL_LOAD', 'GL_MULT', 'GL_RETURN', 'GL_ALPHA_TEST',
'GL_ALPHA_TEST_REF', 'GL_ALPHA_TEST_FUNC', 'GL_BLEND', 'GL_BLEND_SRC',
'GL_BLEND_DST', 'GL_ZERO', 'GL_ONE', 'GL_SRC_COLOR', 'GL_ONE_MINUS_SRC_COLOR',
'GL_SRC_ALPHA', 'GL_ONE_MINUS_SRC_ALPHA', 'GL_DST_ALPHA',
'GL_ONE_MINUS_DST_ALPHA', 'GL_DST_COLOR', 'GL_ONE_MINUS_DST_COLOR',
'GL_SRC_ALPHA_SATURATE', 'GL_FEEDBACK', 'GL_RENDER', 'GL_SELECT', 'GL_2D',
'GL_3D', 'GL_3D_COLOR', 'GL_3D_COLOR_TEXTURE', 'GL_4D_COLOR_TEXTURE',
'GL_POINT_TOKEN', 'GL_LINE_TOKEN', 'GL_LINE_RESET_TOKEN', 'GL_POLYGON_TOKEN',
'GL_BITMAP_TOKEN', 'GL_DRAW_PIXEL_TOKEN', 'GL_COPY_PIXEL_TOKEN',
'GL_PASS_THROUGH_TOKEN', 'GL_FEEDBACK_BUFFER_POINTER',
'GL_FEEDBACK_BUFFER_SIZE', 'GL_FEEDBACK_BUFFER_TYPE',
'GL_SELECTION_BUFFER_POINTER', 'GL_SELECTION_BUFFER_SIZE', 'GL_FOG',
'GL_FOG_MODE', 'GL_FOG_DENSITY', 'GL_FOG_COLOR', 'GL_FOG_INDEX',
'GL_FOG_START', 'GL_FOG_END', 'GL_LINEAR', 'GL_EXP', 'GL_EXP2', 'GL_LOGIC_OP',
'GL_INDEX_LOGIC_OP', 'GL_COLOR_LOGIC_OP', 'GL_LOGIC_OP_MODE', 'GL_CLEAR',
'GL_SET', 'GL_COPY', 'GL_COPY_INVERTED', 'GL_NOOP', 'GL_INVERT', 'GL_AND',
'GL_NAND', 'GL_OR', 'GL_NOR', 'GL_XOR', 'GL_EQUIV', 'GL_AND_REVERSE',
'GL_AND_INVERTED', 'GL_OR_REVERSE', 'GL_OR_INVERTED', 'GL_STENCIL_BITS',
'GL_STENCIL_TEST', 'GL_STENCIL_CLEAR_VALUE', 'GL_STENCIL_FUNC',
'GL_STENCIL_VALUE_MASK', 'GL_STENCIL_FAIL', 'GL_STENCIL_PASS_DEPTH_FAIL',
'GL_STENCIL_PASS_DEPTH_PASS', 'GL_STENCIL_REF', 'GL_STENCIL_WRITEMASK',
'GL_STENCIL_INDEX', 'GL_KEEP', 'GL_REPLACE', 'GL_INCR', 'GL_DECR', 'GL_NONE',
'GL_LEFT', 'GL_RIGHT', 'GL_FRONT_LEFT', 'GL_FRONT_RIGHT', 'GL_BACK_LEFT',
'GL_BACK_RIGHT', 'GL_AUX0', 'GL_AUX1', 'GL_AUX2', 'GL_AUX3', 'GL_COLOR_INDEX',
'GL_RED', 'GL_GREEN', 'GL_BLUE', 'GL_ALPHA', 'GL_LUMINANCE',
'GL_LUMINANCE_ALPHA', 'GL_ALPHA_BITS', 'GL_RED_BITS', 'GL_GREEN_BITS',
'GL_BLUE_BITS', 'GL_INDEX_BITS', 'GL_SUBPIXEL_BITS', 'GL_AUX_BUFFERS',
'GL_READ_BUFFER', 'GL_DRAW_BUFFER', 'GL_DOUBLEBUFFER', 'GL_STEREO',
'GL_BITMAP', 'GL_COLOR', 'GL_DEPTH', 'GL_STENCIL', 'GL_DITHER', 'GL_RGB',
'GL_RGBA', 'GL_MAX_LIST_NESTING', 'GL_MAX_EVAL_ORDER', 'GL_MAX_LIGHTS',
'GL_MAX_CLIP_PLANES', 'GL_MAX_TEXTURE_SIZE', 'GL_MAX_PIXEL_MAP_TABLE',
'GL_MAX_ATTRIB_STACK_DEPTH', 'GL_MAX_MODELVIEW_STACK_DEPTH',
'GL_MAX_NAME_STACK_DEPTH', 'GL_MAX_PROJECTION_STACK_DEPTH',
'GL_MAX_TEXTURE_STACK_DEPTH', 'GL_MAX_VIEWPORT_DIMS',
'GL_MAX_CLIENT_ATTRIB_STACK_DEPTH', 'GL_ATTRIB_STACK_DEPTH',
'GL_CLIENT_ATTRIB_STACK_DEPTH', 'GL_COLOR_CLEAR_VALUE', 'GL_COLOR_WRITEMASK',
'GL_CURRENT_INDEX', 'GL_CURRENT_COLOR', 'GL_CURRENT_NORMAL',
'GL_CURRENT_RASTER_COLOR', 'GL_CURRENT_RASTER_DISTANCE',
'GL_CURRENT_RASTER_INDEX', 'GL_CURRENT_RASTER_POSITION',
'GL_CURRENT_RASTER_TEXTURE_COORDS', 'GL_CURRENT_RASTER_POSITION_VALID',
'GL_CURRENT_TEXTURE_COORDS', 'GL_INDEX_CLEAR_VALUE', 'GL_INDEX_MODE',
'GL_INDEX_WRITEMASK', 'GL_MODELVIEW_MATRIX', 'GL_MODELVIEW_STACK_DEPTH',
'GL_NAME_STACK_DEPTH', 'GL_PROJECTION_MATRIX', 'GL_PROJECTION_STACK_DEPTH',
'GL_RENDER_MODE', 'GL_RGBA_MODE', 'GL_TEXTURE_MATRIX',
'GL_TEXTURE_STACK_DEPTH', 'GL_VIEWPORT', 'GL_AUTO_NORMAL', 'GL_MAP1_COLOR_4',
'GL_MAP1_INDEX', 'GL_MAP1_NORMAL', 'GL_MAP1_TEXTURE_COORD_1',
'GL_MAP1_TEXTURE_COORD_2', 'GL_MAP1_TEXTURE_COORD_3',
'GL_MAP1_TEXTURE_COORD_4', 'GL_MAP1_VERTEX_3', 'GL_MAP1_VERTEX_4',
'GL_MAP2_COLOR_4', 'GL_MAP2_INDEX', 'GL_MAP2_NORMAL',
'GL_MAP2_TEXTURE_COORD_1', 'GL_MAP2_TEXTURE_COORD_2',
'GL_MAP2_TEXTURE_COORD_3', 'GL_MAP2_TEXTURE_COORD_4', 'GL_MAP2_VERTEX_3',
'GL_MAP2_VERTEX_4', 'GL_MAP1_GRID_DOMAIN', 'GL_MAP1_GRID_SEGMENTS',
'GL_MAP2_GRID_DOMAIN', 'GL_MAP2_GRID_SEGMENTS', 'GL_COEFF', 'GL_ORDER',
'GL_DOMAIN', 'GL_PERSPECTIVE_CORRECTION_HINT', 'GL_POINT_SMOOTH_HINT',
'GL_LINE_SMOOTH_HINT', 'GL_POLYGON_SMOOTH_HINT', 'GL_FOG_HINT',
'GL_DONT_CARE', 'GL_FASTEST', 'GL_NICEST', 'GL_SCISSOR_BOX',
'GL_SCISSOR_TEST', 'GL_MAP_COLOR', 'GL_MAP_STENCIL', 'GL_INDEX_SHIFT',
'GL_INDEX_OFFSET', 'GL_RED_SCALE', 'GL_RED_BIAS', 'GL_GREEN_SCALE',
'GL_GREEN_BIAS', 'GL_BLUE_SCALE', 'GL_BLUE_BIAS', 'GL_ALPHA_SCALE',
'GL_ALPHA_BIAS', 'GL_DEPTH_SCALE', 'GL_DEPTH_BIAS',
'GL_PIXEL_MAP_S_TO_S_SIZE', 'GL_PIXEL_MAP_I_TO_I_SIZE',
'GL_PIXEL_MAP_I_TO_R_SIZE', 'GL_PIXEL_MAP_I_TO_G_SIZE',
'GL_PIXEL_MAP_I_TO_B_SIZE', 'GL_PIXEL_MAP_I_TO_A_SIZE',
'GL_PIXEL_MAP_R_TO_R_SIZE', 'GL_PIXEL_MAP_G_TO_G_SIZE',
'GL_PIXEL_MAP_B_TO_B_SIZE', 'GL_PIXEL_MAP_A_TO_A_SIZE', 'GL_PIXEL_MAP_S_TO_S',
'GL_PIXEL_MAP_I_TO_I', 'GL_PIXEL_MAP_I_TO_R', 'GL_PIXEL_MAP_I_TO_G',
'GL_PIXEL_MAP_I_TO_B', 'GL_PIXEL_MAP_I_TO_A', 'GL_PIXEL_MAP_R_TO_R',
'GL_PIXEL_MAP_G_TO_G', 'GL_PIXEL_MAP_B_TO_B', 'GL_PIXEL_MAP_A_TO_A',
'GL_PACK_ALIGNMENT', 'GL_PACK_LSB_FIRST', 'GL_PACK_ROW_LENGTH',
'GL_PACK_SKIP_PIXELS', 'GL_PACK_SKIP_ROWS', 'GL_PACK_SWAP_BYTES',
'GL_UNPACK_ALIGNMENT', 'GL_UNPACK_LSB_FIRST', 'GL_UNPACK_ROW_LENGTH',
'GL_UNPACK_SKIP_PIXELS', 'GL_UNPACK_SKIP_ROWS', 'GL_UNPACK_SWAP_BYTES',
'GL_ZOOM_X', 'GL_ZOOM_Y', 'GL_TEXTURE_ENV', 'GL_TEXTURE_ENV_MODE',
'GL_TEXTURE_1D', 'GL_TEXTURE_2D', 'GL_TEXTURE_WRAP_S', 'GL_TEXTURE_WRAP_T',
'GL_TEXTURE_MAG_FILTER', 'GL_TEXTURE_MIN_FILTER', 'GL_TEXTURE_ENV_COLOR',
'GL_TEXTURE_GEN_S', 'GL_TEXTURE_GEN_T', 'GL_TEXTURE_GEN_R',
'GL_TEXTURE_GEN_Q', 'GL_TEXTURE_GEN_MODE', 'GL_TEXTURE_BORDER_COLOR',
'GL_TEXTURE_WIDTH', 'GL_TEXTURE_HEIGHT', 'GL_TEXTURE_BORDER',
'GL_TEXTURE_COMPONENTS', 'GL_TEXTURE_RED_SIZE', 'GL_TEXTURE_GREEN_SIZE',
'GL_TEXTURE_BLUE_SIZE', 'GL_TEXTURE_ALPHA_SIZE', 'GL_TEXTURE_LUMINANCE_SIZE',
'GL_TEXTURE_INTENSITY_SIZE', 'GL_NEAREST_MIPMAP_NEAREST',
'GL_NEAREST_MIPMAP_LINEAR', 'GL_LINEAR_MIPMAP_NEAREST',
'GL_LINEAR_MIPMAP_LINEAR', 'GL_OBJECT_LINEAR', 'GL_OBJECT_PLANE',
'GL_EYE_LINEAR', 'GL_EYE_PLANE', 'GL_SPHERE_MAP', 'GL_DECAL', 'GL_MODULATE',
'GL_NEAREST', 'GL_REPEAT', 'GL_CLAMP', 'GL_S', 'GL_T', 'GL_R', 'GL_Q',
'GL_VENDOR', 'GL_RENDERER', 'GL_VERSION', 'GL_EXTENSIONS', 'GL_NO_ERROR',
'GL_INVALID_ENUM', 'GL_INVALID_VALUE', 'GL_INVALID_OPERATION',
'GL_STACK_OVERFLOW', 'GL_STACK_UNDERFLOW', 'GL_OUT_OF_MEMORY',
'GL_CURRENT_BIT', 'GL_POINT_BIT', 'GL_LINE_BIT', 'GL_POLYGON_BIT',
'GL_POLYGON_STIPPLE_BIT', 'GL_PIXEL_MODE_BIT', 'GL_LIGHTING_BIT',
'GL_FOG_BIT', 'GL_DEPTH_BUFFER_BIT', 'GL_ACCUM_BUFFER_BIT',
'GL_STENCIL_BUFFER_BIT', 'GL_VIEWPORT_BIT', 'GL_TRANSFORM_BIT',
'GL_ENABLE_BIT', 'GL_COLOR_BUFFER_BIT', 'GL_HINT_BIT', 'GL_EVAL_BIT',
'GL_LIST_BIT', 'GL_TEXTURE_BIT', 'GL_SCISSOR_BIT', 'GL_ALL_ATTRIB_BITS',
'GL_PROXY_TEXTURE_1D', 'GL_PROXY_TEXTURE_2D', 'GL_TEXTURE_PRIORITY',
'GL_TEXTURE_RESIDENT', 'GL_TEXTURE_BINDING_1D', 'GL_TEXTURE_BINDING_2D',
'GL_TEXTURE_INTERNAL_FORMAT', 'GL_ALPHA4', 'GL_ALPHA8', 'GL_ALPHA12',
'GL_ALPHA16', 'GL_LUMINANCE4', 'GL_LUMINANCE8', 'GL_LUMINANCE12',
'GL_LUMINANCE16', 'GL_LUMINANCE4_ALPHA4', 'GL_LUMINANCE6_ALPHA2',
'GL_LUMINANCE8_ALPHA8', 'GL_LUMINANCE12_ALPHA4', 'GL_LUMINANCE12_ALPHA12',
'GL_LUMINANCE16_ALPHA16', 'GL_INTENSITY', 'GL_INTENSITY4', 'GL_INTENSITY8',
'GL_INTENSITY12', 'GL_INTENSITY16', 'GL_R3_G3_B2', 'GL_RGB4', 'GL_RGB5',
'GL_RGB8', 'GL_RGB10', 'GL_RGB12', 'GL_RGB16', 'GL_RGBA2', 'GL_RGBA4',
'GL_RGB5_A1', 'GL_RGBA8', 'GL_RGB10_A2', 'GL_RGBA12', 'GL_RGBA16',
'GL_CLIENT_PIXEL_STORE_BIT', 'GL_CLIENT_VERTEX_ARRAY_BIT',
'GL_ALL_CLIENT_ATTRIB_BITS', 'GL_CLIENT_ALL_ATTRIB_BITS', 'glClearIndex',
'glClearColor', 'glClear', 'glIndexMask', 'glColorMask', 'glAlphaFunc',
'glBlendFunc', 'glLogicOp', 'glCullFace', 'glFrontFace', 'glPointSize',
'glLineWidth', 'glLineStipple', 'glPolygonMode', 'glPolygonOffset',
'glPolygonStipple', 'glGetPolygonStipple', 'glEdgeFlag', 'glEdgeFlagv',
'glScissor', 'glClipPlane', 'glGetClipPlane', 'glDrawBuffer', 'glReadBuffer',
'glEnable', 'glDisable', 'glIsEnabled', 'glEnableClientState',
'glDisableClientState', 'glGetBooleanv', 'glGetDoublev', 'glGetFloatv',
'glGetIntegerv', 'glPushAttrib', 'glPopAttrib', 'glPushClientAttrib',
'glPopClientAttrib', 'glRenderMode', 'glGetError', 'glGetString', 'glFinish',
'glFlush', 'glHint', 'glClearDepth', 'glDepthFunc', 'glDepthMask',
'glDepthRange', 'glClearAccum', 'glAccum', 'glMatrixMode', 'glOrtho',
'glFrustum', 'glViewport', 'glPushMatrix', 'glPopMatrix', 'glLoadIdentity',
'glLoadMatrixd', 'glLoadMatrixf', 'glMultMatrixd', 'glMultMatrixf',
'glRotated', 'glRotatef', 'glScaled', 'glScalef', 'glTranslated',
'glTranslatef', 'glIsList', 'glDeleteLists', 'glGenLists', 'glNewList',
'glEndList', 'glCallList', 'glCallLists', 'glListBase', 'glBegin', 'glEnd',
'glVertex2d', 'glVertex2f', 'glVertex2i', 'glVertex2s', 'glVertex3d',
'glVertex3f', 'glVertex3i', 'glVertex3s', 'glVertex4d', 'glVertex4f',
'glVertex4i', 'glVertex4s', 'glVertex2dv', 'glVertex2fv', 'glVertex2iv',
'glVertex2sv', 'glVertex3dv', 'glVertex3fv', 'glVertex3iv', 'glVertex3sv',
'glVertex4dv', 'glVertex4fv', 'glVertex4iv', 'glVertex4sv', 'glNormal3b',
'glNormal3d', 'glNormal3f', 'glNormal3i', 'glNormal3s', 'glNormal3bv',
'glNormal3dv', 'glNormal3fv', 'glNormal3iv', 'glNormal3sv', 'glIndexd',
'glIndexf', 'glIndexi', 'glIndexs', 'glIndexub', 'glIndexdv', 'glIndexfv',
'glIndexiv', 'glIndexsv', 'glIndexubv', 'glColor3b', 'glColor3d', 'glColor3f',
'glColor3i', 'glColor3s', 'glColor3ub', 'glColor3ui', 'glColor3us',
'glColor4b', 'glColor4d', 'glColor4f', 'glColor4i', 'glColor4s', 'glColor4ub',
'glColor4ui', 'glColor4us', 'glColor3bv', 'glColor3dv', 'glColor3fv',
'glColor3iv', 'glColor3sv', 'glColor3ubv', 'glColor3uiv', 'glColor3usv',
'glColor4bv', 'glColor4dv', 'glColor4fv', 'glColor4iv', 'glColor4sv',
'glColor4ubv', 'glColor4uiv', 'glColor4usv', 'glTexCoord1d', 'glTexCoord1f',
'glTexCoord1i', 'glTexCoord1s', 'glTexCoord2d', 'glTexCoord2f',
'glTexCoord2i', 'glTexCoord2s', 'glTexCoord3d', 'glTexCoord3f',
'glTexCoord3i', 'glTexCoord3s', 'glTexCoord4d', 'glTexCoord4f',
'glTexCoord4i', 'glTexCoord4s', 'glTexCoord1dv', 'glTexCoord1fv',
'glTexCoord1iv', 'glTexCoord1sv', 'glTexCoord2dv', 'glTexCoord2fv',
'glTexCoord2iv', 'glTexCoord2sv', 'glTexCoord3dv', 'glTexCoord3fv',
'glTexCoord3iv', 'glTexCoord3sv', 'glTexCoord4dv', 'glTexCoord4fv',
'glTexCoord4iv', 'glTexCoord4sv', 'glRasterPos2d', 'glRasterPos2f',
'glRasterPos2i', 'glRasterPos2s', 'glRasterPos3d', 'glRasterPos3f',
'glRasterPos3i', 'glRasterPos3s', 'glRasterPos4d', 'glRasterPos4f',
'glRasterPos4i', 'glRasterPos4s', 'glRasterPos2dv', 'glRasterPos2fv',
'glRasterPos2iv', 'glRasterPos2sv', 'glRasterPos3dv', 'glRasterPos3fv',
'glRasterPos3iv', 'glRasterPos3sv', 'glRasterPos4dv', 'glRasterPos4fv',
'glRasterPos4iv', 'glRasterPos4sv', 'glRectd', 'glRectf', 'glRecti',
'glRects', 'glRectdv', 'glRectfv', 'glRectiv', 'glRectsv', 'glVertexPointer',
'glNormalPointer', 'glColorPointer', 'glIndexPointer', 'glTexCoordPointer',
'glEdgeFlagPointer', 'glGetPointerv', 'glArrayElement', 'glDrawArrays',
'glDrawElements', 'glInterleavedArrays', 'glShadeModel', 'glLightf',
'glLighti', 'glLightfv', 'glLightiv', 'glGetLightfv', 'glGetLightiv',
'glLightModelf', 'glLightModeli', 'glLightModelfv', 'glLightModeliv',
'glMaterialf', 'glMateriali', 'glMaterialfv', 'glMaterialiv',
'glGetMaterialfv', 'glGetMaterialiv', 'glColorMaterial', 'glPixelZoom',
'glPixelStoref', 'glPixelStorei', 'glPixelTransferf', 'glPixelTransferi',
'glPixelMapfv', 'glPixelMapuiv', 'glPixelMapusv', 'glGetPixelMapfv',
'glGetPixelMapuiv', 'glGetPixelMapusv', 'glBitmap', 'glReadPixels',
'glDrawPixels', 'glCopyPixels', 'glStencilFunc', 'glStencilMask',
'glStencilOp', 'glClearStencil', 'glTexGend', 'glTexGenf', 'glTexGeni',
'glTexGendv', 'glTexGenfv', 'glTexGeniv', 'glGetTexGendv', 'glGetTexGenfv',
'glGetTexGeniv', 'glTexEnvf', 'glTexEnvi', 'glTexEnvfv', 'glTexEnviv',
'glGetTexEnvfv', 'glGetTexEnviv', 'glTexParameterf', 'glTexParameteri',
'glTexParameterfv', 'glTexParameteriv', 'glGetTexParameterfv',
'glGetTexParameteriv', 'glGetTexLevelParameterfv', 'glGetTexLevelParameteriv',
'glTexImage1D', 'glTexImage2D', 'glGetTexImage', 'glGenTextures',
'glDeleteTextures', 'glBindTexture', 'glPrioritizeTextures',
'glAreTexturesResident', 'glIsTexture', 'glTexSubImage1D', 'glTexSubImage2D',
'glCopyTexImage1D', 'glCopyTexImage2D', 'glCopyTexSubImage1D',
'glCopyTexSubImage2D', 'glMap1d', 'glMap1f', 'glMap2d', 'glMap2f',
'glGetMapdv', 'glGetMapfv', 'glGetMapiv', 'glEvalCoord1d', 'glEvalCoord1f',
'glEvalCoord1dv', 'glEvalCoord1fv', 'glEvalCoord2d', 'glEvalCoord2f',
'glEvalCoord2dv', 'glEvalCoord2fv', 'glMapGrid1d', 'glMapGrid1f',
'glMapGrid2d', 'glMapGrid2f', 'glEvalPoint1', 'glEvalPoint2', 'glEvalMesh1',
'glEvalMesh2', 'glFogf', 'glFogi', 'glFogfv', 'glFogiv', 'glFeedbackBuffer',
'glPassThrough', 'glSelectBuffer', 'glInitNames', 'glLoadName', 'glPushName',
'glPopName', 'GL_RESCALE_NORMAL', 'GL_CLAMP_TO_EDGE',
'GL_MAX_ELEMENTS_VERTICES', 'GL_MAX_ELEMENTS_INDICES', 'GL_BGR', 'GL_BGRA',
'GL_UNSIGNED_BYTE_3_3_2', 'GL_UNSIGNED_BYTE_2_3_3_REV',
'GL_UNSIGNED_SHORT_5_6_5', 'GL_UNSIGNED_SHORT_5_6_5_REV',
'GL_UNSIGNED_SHORT_4_4_4_4', 'GL_UNSIGNED_SHORT_4_4_4_4_REV',
'GL_UNSIGNED_SHORT_5_5_5_1', 'GL_UNSIGNED_SHORT_1_5_5_5_REV',
'GL_UNSIGNED_INT_8_8_8_8', 'GL_UNSIGNED_INT_8_8_8_8_REV',
'GL_UNSIGNED_INT_10_10_10_2', 'GL_UNSIGNED_INT_2_10_10_10_REV',
'GL_LIGHT_MODEL_COLOR_CONTROL', 'GL_SINGLE_COLOR',
'GL_SEPARATE_SPECULAR_COLOR', 'GL_TEXTURE_MIN_LOD', 'GL_TEXTURE_MAX_LOD',
'GL_TEXTURE_BASE_LEVEL', 'GL_TEXTURE_MAX_LEVEL', 'GL_SMOOTH_POINT_SIZE_RANGE',
'GL_SMOOTH_POINT_SIZE_GRANULARITY', 'GL_SMOOTH_LINE_WIDTH_RANGE',
'GL_SMOOTH_LINE_WIDTH_GRANULARITY', 'GL_ALIASED_POINT_SIZE_RANGE',
'GL_ALIASED_LINE_WIDTH_RANGE', 'GL_PACK_SKIP_IMAGES', 'GL_PACK_IMAGE_HEIGHT',
'GL_UNPACK_SKIP_IMAGES', 'GL_UNPACK_IMAGE_HEIGHT', 'GL_TEXTURE_3D',
'GL_PROXY_TEXTURE_3D', 'GL_TEXTURE_DEPTH', 'GL_TEXTURE_WRAP_R',
'GL_MAX_3D_TEXTURE_SIZE', 'GL_TEXTURE_BINDING_3D', 'glDrawRangeElements',
'glTexImage3D', 'glTexSubImage3D', 'glCopyTexSubImage3D',
'PFNGLDRAWRANGEELEMENTSPROC', 'PFNGLTEXIMAGE3DPROC', 'PFNGLTEXSUBIMAGE3DPROC',
'PFNGLCOPYTEXSUBIMAGE3DPROC', 'GL_CONSTANT_COLOR',
'GL_ONE_MINUS_CONSTANT_COLOR', 'GL_CONSTANT_ALPHA',
'GL_ONE_MINUS_CONSTANT_ALPHA', 'GL_COLOR_TABLE',
'GL_POST_CONVOLUTION_COLOR_TABLE', 'GL_POST_COLOR_MATRIX_COLOR_TABLE',
'GL_PROXY_COLOR_TABLE', 'GL_PROXY_POST_CONVOLUTION_COLOR_TABLE',
'GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE', 'GL_COLOR_TABLE_SCALE',
'GL_COLOR_TABLE_BIAS', 'GL_COLOR_TABLE_FORMAT', 'GL_COLOR_TABLE_WIDTH',
'GL_COLOR_TABLE_RED_SIZE', 'GL_COLOR_TABLE_GREEN_SIZE',
'GL_COLOR_TABLE_BLUE_SIZE', 'GL_COLOR_TABLE_ALPHA_SIZE',
'GL_COLOR_TABLE_LUMINANCE_SIZE', 'GL_COLOR_TABLE_INTENSITY_SIZE',
'GL_CONVOLUTION_1D', 'GL_CONVOLUTION_2D', 'GL_SEPARABLE_2D',
'GL_CONVOLUTION_BORDER_MODE', 'GL_CONVOLUTION_FILTER_SCALE',
'GL_CONVOLUTION_FILTER_BIAS', 'GL_REDUCE', 'GL_CONVOLUTION_FORMAT',
'GL_CONVOLUTION_WIDTH', 'GL_CONVOLUTION_HEIGHT', 'GL_MAX_CONVOLUTION_WIDTH',
'GL_MAX_CONVOLUTION_HEIGHT', 'GL_POST_CONVOLUTION_RED_SCALE',
'GL_POST_CONVOLUTION_GREEN_SCALE', 'GL_POST_CONVOLUTION_BLUE_SCALE',
'GL_POST_CONVOLUTION_ALPHA_SCALE', 'GL_POST_CONVOLUTION_RED_BIAS',
'GL_POST_CONVOLUTION_GREEN_BIAS', 'GL_POST_CONVOLUTION_BLUE_BIAS',
'GL_POST_CONVOLUTION_ALPHA_BIAS', 'GL_CONSTANT_BORDER', 'GL_REPLICATE_BORDER',
'GL_CONVOLUTION_BORDER_COLOR', 'GL_COLOR_MATRIX',
'GL_COLOR_MATRIX_STACK_DEPTH', 'GL_MAX_COLOR_MATRIX_STACK_DEPTH',
'GL_POST_COLOR_MATRIX_RED_SCALE', 'GL_POST_COLOR_MATRIX_GREEN_SCALE',
'GL_POST_COLOR_MATRIX_BLUE_SCALE', 'GL_POST_COLOR_MATRIX_ALPHA_SCALE',
'GL_POST_COLOR_MATRIX_RED_BIAS', 'GL_POST_COLOR_MATRIX_GREEN_BIAS',
'GL_POST_COLOR_MATRIX_BLUE_BIAS', 'GL_POST_COLOR_MATRIX_ALPHA_BIAS',
'GL_HISTOGRAM', 'GL_PROXY_HISTOGRAM', 'GL_HISTOGRAM_WIDTH',
'GL_HISTOGRAM_FORMAT', 'GL_HISTOGRAM_RED_SIZE', 'GL_HISTOGRAM_GREEN_SIZE',
'GL_HISTOGRAM_BLUE_SIZE', 'GL_HISTOGRAM_ALPHA_SIZE',
'GL_HISTOGRAM_LUMINANCE_SIZE', 'GL_HISTOGRAM_SINK', 'GL_MINMAX',
'GL_MINMAX_FORMAT', 'GL_MINMAX_SINK', 'GL_TABLE_TOO_LARGE',
'GL_BLEND_EQUATION', 'GL_MIN', 'GL_MAX', 'GL_FUNC_ADD', 'GL_FUNC_SUBTRACT',
'GL_FUNC_REVERSE_SUBTRACT', 'GL_BLEND_COLOR', 'glColorTable',
'glColorSubTable', 'glColorTableParameteriv', 'glColorTableParameterfv',
'glCopyColorSubTable', 'glCopyColorTable', 'glGetColorTable',
'glGetColorTableParameterfv', 'glGetColorTableParameteriv', 'glBlendEquation',
'glBlendColor', 'glHistogram', 'glResetHistogram', 'glGetHistogram',
'glGetHistogramParameterfv', 'glGetHistogramParameteriv', 'glMinmax',
'glResetMinmax', 'glGetMinmax', 'glGetMinmaxParameterfv',
'glGetMinmaxParameteriv', 'glConvolutionFilter1D', 'glConvolutionFilter2D',
'glConvolutionParameterf', 'glConvolutionParameterfv',
'glConvolutionParameteri', 'glConvolutionParameteriv',
'glCopyConvolutionFilter1D', 'glCopyConvolutionFilter2D',
'glGetConvolutionFilter', 'glGetConvolutionParameterfv',
'glGetConvolutionParameteriv', 'glSeparableFilter2D', 'glGetSeparableFilter',
'PFNGLBLENDCOLORPROC', 'PFNGLBLENDEQUATIONPROC', 'GL_TEXTURE0', 'GL_TEXTURE1',
'GL_TEXTURE2', 'GL_TEXTURE3', 'GL_TEXTURE4', 'GL_TEXTURE5', 'GL_TEXTURE6',
'GL_TEXTURE7', 'GL_TEXTURE8', 'GL_TEXTURE9', 'GL_TEXTURE10', 'GL_TEXTURE11',
'GL_TEXTURE12', 'GL_TEXTURE13', 'GL_TEXTURE14', 'GL_TEXTURE15',
'GL_TEXTURE16', 'GL_TEXTURE17', 'GL_TEXTURE18', 'GL_TEXTURE19',
'GL_TEXTURE20', 'GL_TEXTURE21', 'GL_TEXTURE22', 'GL_TEXTURE23',
'GL_TEXTURE24', 'GL_TEXTURE25', 'GL_TEXTURE26', 'GL_TEXTURE27',
'GL_TEXTURE28', 'GL_TEXTURE29', 'GL_TEXTURE30', 'GL_TEXTURE31',
'GL_ACTIVE_TEXTURE', 'GL_CLIENT_ACTIVE_TEXTURE', 'GL_MAX_TEXTURE_UNITS',
'GL_NORMAL_MAP', 'GL_REFLECTION_MAP', 'GL_TEXTURE_CUBE_MAP',
'GL_TEXTURE_BINDING_CUBE_MAP', 'GL_TEXTURE_CUBE_MAP_POSITIVE_X',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_X', 'GL_TEXTURE_CUBE_MAP_POSITIVE_Y',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y', 'GL_TEXTURE_CUBE_MAP_POSITIVE_Z',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z', 'GL_PROXY_TEXTURE_CUBE_MAP',
'GL_MAX_CUBE_MAP_TEXTURE_SIZE', 'GL_COMPRESSED_ALPHA',
'GL_COMPRESSED_LUMINANCE', 'GL_COMPRESSED_LUMINANCE_ALPHA',
'GL_COMPRESSED_INTENSITY', 'GL_COMPRESSED_RGB', 'GL_COMPRESSED_RGBA',
'GL_TEXTURE_COMPRESSION_HINT', 'GL_TEXTURE_COMPRESSED_IMAGE_SIZE',
'GL_TEXTURE_COMPRESSED', 'GL_NUM_COMPRESSED_TEXTURE_FORMATS',
'GL_COMPRESSED_TEXTURE_FORMATS', 'GL_MULTISAMPLE',
'GL_SAMPLE_ALPHA_TO_COVERAGE', 'GL_SAMPLE_ALPHA_TO_ONE', 'GL_SAMPLE_COVERAGE',
'GL_SAMPLE_BUFFERS', 'GL_SAMPLES', 'GL_SAMPLE_COVERAGE_VALUE',
'GL_SAMPLE_COVERAGE_INVERT', 'GL_MULTISAMPLE_BIT',
'GL_TRANSPOSE_MODELVIEW_MATRIX', 'GL_TRANSPOSE_PROJECTION_MATRIX',
'GL_TRANSPOSE_TEXTURE_MATRIX', 'GL_TRANSPOSE_COLOR_MATRIX', 'GL_COMBINE',
'GL_COMBINE_RGB', 'GL_COMBINE_ALPHA', 'GL_SOURCE0_RGB', 'GL_SOURCE1_RGB',
'GL_SOURCE2_RGB', 'GL_SOURCE0_ALPHA', 'GL_SOURCE1_ALPHA', 'GL_SOURCE2_ALPHA',
'GL_OPERAND0_RGB', 'GL_OPERAND1_RGB', 'GL_OPERAND2_RGB', 'GL_OPERAND0_ALPHA',
'GL_OPERAND1_ALPHA', 'GL_OPERAND2_ALPHA', 'GL_RGB_SCALE', 'GL_ADD_SIGNED',
'GL_INTERPOLATE', 'GL_SUBTRACT', 'GL_CONSTANT', 'GL_PRIMARY_COLOR',
'GL_PREVIOUS', 'GL_DOT3_RGB', 'GL_DOT3_RGBA', 'GL_CLAMP_TO_BORDER',
'glActiveTexture', 'glClientActiveTexture', 'glCompressedTexImage1D',
'glCompressedTexImage2D', 'glCompressedTexImage3D',
'glCompressedTexSubImage1D', 'glCompressedTexSubImage2D',
'glCompressedTexSubImage3D', 'glGetCompressedTexImage', 'glMultiTexCoord1d',
'glMultiTexCoord1dv', 'glMultiTexCoord1f', 'glMultiTexCoord1fv',
'glMultiTexCoord1i', 'glMultiTexCoord1iv', 'glMultiTexCoord1s',
'glMultiTexCoord1sv', 'glMultiTexCoord2d', 'glMultiTexCoord2dv',
'glMultiTexCoord2f', 'glMultiTexCoord2fv', 'glMultiTexCoord2i',
'glMultiTexCoord2iv', 'glMultiTexCoord2s', 'glMultiTexCoord2sv',
'glMultiTexCoord3d', 'glMultiTexCoord3dv', 'glMultiTexCoord3f',
'glMultiTexCoord3fv', 'glMultiTexCoord3i', 'glMultiTexCoord3iv',
'glMultiTexCoord3s', 'glMultiTexCoord3sv', 'glMultiTexCoord4d',
'glMultiTexCoord4dv', 'glMultiTexCoord4f', 'glMultiTexCoord4fv',
'glMultiTexCoord4i', 'glMultiTexCoord4iv', 'glMultiTexCoord4s',
'glMultiTexCoord4sv', 'glLoadTransposeMatrixd', 'glLoadTransposeMatrixf',
'glMultTransposeMatrixd', 'glMultTransposeMatrixf', 'glSampleCoverage',
'PFNGLACTIVETEXTUREPROC', 'PFNGLSAMPLECOVERAGEPROC',
'PFNGLCOMPRESSEDTEXIMAGE3DPROC', 'PFNGLCOMPRESSEDTEXIMAGE2DPROC',
'PFNGLCOMPRESSEDTEXIMAGE1DPROC', 'PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC',
'PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC', 'PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC',
'PFNGLGETCOMPRESSEDTEXIMAGEPROC', 'GL_ARB_multitexture', 'GL_TEXTURE0_ARB',
'GL_TEXTURE1_ARB', 'GL_TEXTURE2_ARB', 'GL_TEXTURE3_ARB', 'GL_TEXTURE4_ARB',
'GL_TEXTURE5_ARB', 'GL_TEXTURE6_ARB', 'GL_TEXTURE7_ARB', 'GL_TEXTURE8_ARB',
'GL_TEXTURE9_ARB', 'GL_TEXTURE10_ARB', 'GL_TEXTURE11_ARB', 'GL_TEXTURE12_ARB',
'GL_TEXTURE13_ARB', 'GL_TEXTURE14_ARB', 'GL_TEXTURE15_ARB',
'GL_TEXTURE16_ARB', 'GL_TEXTURE17_ARB', 'GL_TEXTURE18_ARB',
'GL_TEXTURE19_ARB', 'GL_TEXTURE20_ARB', 'GL_TEXTURE21_ARB',
'GL_TEXTURE22_ARB', 'GL_TEXTURE23_ARB', 'GL_TEXTURE24_ARB',
'GL_TEXTURE25_ARB', 'GL_TEXTURE26_ARB', 'GL_TEXTURE27_ARB',
'GL_TEXTURE28_ARB', 'GL_TEXTURE29_ARB', 'GL_TEXTURE30_ARB',
'GL_TEXTURE31_ARB', 'GL_ACTIVE_TEXTURE_ARB', 'GL_CLIENT_ACTIVE_TEXTURE_ARB',
'GL_MAX_TEXTURE_UNITS_ARB', 'glActiveTextureARB', 'glClientActiveTextureARB',
'glMultiTexCoord1dARB', 'glMultiTexCoord1dvARB', 'glMultiTexCoord1fARB',
'glMultiTexCoord1fvARB', 'glMultiTexCoord1iARB', 'glMultiTexCoord1ivARB',
'glMultiTexCoord1sARB', 'glMultiTexCoord1svARB', 'glMultiTexCoord2dARB',
'glMultiTexCoord2dvARB', 'glMultiTexCoord2fARB', 'glMultiTexCoord2fvARB',
'glMultiTexCoord2iARB', 'glMultiTexCoord2ivARB', 'glMultiTexCoord2sARB',
'glMultiTexCoord2svARB', 'glMultiTexCoord3dARB', 'glMultiTexCoord3dvARB',
'glMultiTexCoord3fARB', 'glMultiTexCoord3fvARB', 'glMultiTexCoord3iARB',
'glMultiTexCoord3ivARB', 'glMultiTexCoord3sARB', 'glMultiTexCoord3svARB',
'glMultiTexCoord4dARB', 'glMultiTexCoord4dvARB', 'glMultiTexCoord4fARB',
'glMultiTexCoord4fvARB', 'glMultiTexCoord4iARB', 'glMultiTexCoord4ivARB',
'glMultiTexCoord4sARB', 'glMultiTexCoord4svARB', 'PFNGLACTIVETEXTUREARBPROC',
'PFNGLCLIENTACTIVETEXTUREARBPROC', 'PFNGLMULTITEXCOORD1DARBPROC',
'PFNGLMULTITEXCOORD1DVARBPROC', 'PFNGLMULTITEXCOORD1FARBPROC',
'PFNGLMULTITEXCOORD1FVARBPROC', 'PFNGLMULTITEXCOORD1IARBPROC',
'PFNGLMULTITEXCOORD1IVARBPROC', 'PFNGLMULTITEXCOORD1SARBPROC',
'PFNGLMULTITEXCOORD1SVARBPROC', 'PFNGLMULTITEXCOORD2DARBPROC',
'PFNGLMULTITEXCOORD2DVARBPROC', 'PFNGLMULTITEXCOORD2FARBPROC',
'PFNGLMULTITEXCOORD2FVARBPROC', 'PFNGLMULTITEXCOORD2IARBPROC',
'PFNGLMULTITEXCOORD2IVARBPROC', 'PFNGLMULTITEXCOORD2SARBPROC',
'PFNGLMULTITEXCOORD2SVARBPROC', 'PFNGLMULTITEXCOORD3DARBPROC',
'PFNGLMULTITEXCOORD3DVARBPROC', 'PFNGLMULTITEXCOORD3FARBPROC',
'PFNGLMULTITEXCOORD3FVARBPROC', 'PFNGLMULTITEXCOORD3IARBPROC',
'PFNGLMULTITEXCOORD3IVARBPROC', 'PFNGLMULTITEXCOORD3SARBPROC',
'PFNGLMULTITEXCOORD3SVARBPROC', 'PFNGLMULTITEXCOORD4DARBPROC',
'PFNGLMULTITEXCOORD4DVARBPROC', 'PFNGLMULTITEXCOORD4FARBPROC',
'PFNGLMULTITEXCOORD4FVARBPROC', 'PFNGLMULTITEXCOORD4IARBPROC',
'PFNGLMULTITEXCOORD4IVARBPROC', 'PFNGLMULTITEXCOORD4SARBPROC',
'PFNGLMULTITEXCOORD4SVARBPROC', 'GL_MESA_shader_debug',
'GL_DEBUG_OBJECT_MESA', 'GL_DEBUG_PRINT_MESA', 'GL_DEBUG_ASSERT_MESA',
'glCreateDebugObjectMESA', 'glClearDebugLogMESA', 'glGetDebugLogMESA',
'glGetDebugLogLengthMESA', 'GL_MESA_packed_depth_stencil',
'GL_DEPTH_STENCIL_MESA', 'GL_UNSIGNED_INT_24_8_MESA',
'GL_UNSIGNED_INT_8_24_REV_MESA', 'GL_UNSIGNED_SHORT_15_1_MESA',
'GL_UNSIGNED_SHORT_1_15_REV_MESA', 'GL_MESA_program_debug',
'GL_FRAGMENT_PROGRAM_POSITION_MESA', 'GL_FRAGMENT_PROGRAM_CALLBACK_MESA',
'GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA',
'GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA', 'GL_VERTEX_PROGRAM_POSITION_MESA',
'GL_VERTEX_PROGRAM_CALLBACK_MESA', 'GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA',
'GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA', 'GLprogramcallbackMESA',
'glProgramCallbackMESA', 'glGetProgramRegisterfvMESA',
'GL_MESA_texture_array', 'GL_ATI_blend_equation_separate',
'GL_ALPHA_BLEND_EQUATION_ATI', 'glBlendEquationSeparateATI',
'PFNGLBLENDEQUATIONSEPARATEATIPROC', 'GLeglImageOES', 'GL_OES_EGL_image',
'PFNGLEGLIMAGETARGETTEXTURE2DOESPROC',
'PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
import pyglet.lib
from pyglet.gl.lib import missing_function, decorate_function
from pyglet.compat import asbytes
__all__ = ['link_GL', 'link_GLU', 'link_GLX']
gl_lib = pyglet.lib.load_library('GL')
glu_lib = pyglet.lib.load_library('GLU')
# Look for glXGetProcAddressARB extension, use it as fallback (for
# ATI fglrx and DRI drivers).
try:
glXGetProcAddressARB = getattr(gl_lib, 'glXGetProcAddressARB')
glXGetProcAddressARB.restype = POINTER(CFUNCTYPE(None))
glXGetProcAddressARB.argtypes = [POINTER(c_ubyte)]
_have_getprocaddress = True
except AttributeError:
_have_getprocaddress = False
def link_GL(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(gl_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
if _have_getprocaddress:
# Fallback if implemented but not in ABI
bname = cast(pointer(create_string_buffer(asbytes(name))), POINTER(c_ubyte))
addr = glXGetProcAddressARB(bname)
if addr:
ftype = CFUNCTYPE(*((restype,) + tuple(argtypes)))
func = cast(addr, ftype)
decorate_function(func, name)
return func
return missing_function(name, requires, suggestions)
link_GLX = link_GL
def link_GLU(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(glu_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
return missing_function(name, requires, suggestions)
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from pyglet.gl.base import Config, CanvasConfig, Context
from pyglet.gl import ContextException
from pyglet.gl import gl
from pyglet.gl import agl
from pyglet.canvas.cocoa import CocoaCanvas
from pyglet.libs.darwin.cocoapy import *
NSOpenGLPixelFormat = ObjCClass('NSOpenGLPixelFormat')
NSOpenGLContext = ObjCClass('NSOpenGLContext')
# Valid names for GL attributes and their corresponding NSOpenGL constant.
_gl_attributes = {
'double_buffer': NSOpenGLPFADoubleBuffer,
'stereo': NSOpenGLPFAStereo,
'buffer_size': NSOpenGLPFAColorSize,
'sample_buffers': NSOpenGLPFASampleBuffers,
'samples': NSOpenGLPFASamples,
'aux_buffers': NSOpenGLPFAAuxBuffers,
'alpha_size': NSOpenGLPFAAlphaSize,
'depth_size': NSOpenGLPFADepthSize,
'stencil_size': NSOpenGLPFAStencilSize,
# Not exposed by pyglet API (set internally)
'all_renderers': NSOpenGLPFAAllRenderers,
'fullscreen': NSOpenGLPFAFullScreen,
'minimum_policy': NSOpenGLPFAMinimumPolicy,
'maximum_policy': NSOpenGLPFAMaximumPolicy,
'screen_mask' : NSOpenGLPFAScreenMask,
# Not supported in current pyglet API
'color_float': NSOpenGLPFAColorFloat,
'offscreen': NSOpenGLPFAOffScreen,
'sample_alpha': NSOpenGLPFASampleAlpha,
'multisample': NSOpenGLPFAMultisample,
'supersample': NSOpenGLPFASupersample,
}
# NSOpenGL constants which do not require a value.
_boolean_gl_attributes = frozenset([
NSOpenGLPFAAllRenderers,
NSOpenGLPFADoubleBuffer,
NSOpenGLPFAStereo,
NSOpenGLPFAMinimumPolicy,
NSOpenGLPFAMaximumPolicy,
NSOpenGLPFAOffScreen,
NSOpenGLPFAFullScreen,
NSOpenGLPFAColorFloat,
NSOpenGLPFAMultisample,
NSOpenGLPFASupersample,
NSOpenGLPFASampleAlpha,
])
# Attributes for which no NSOpenGLPixelFormatAttribute name exists.
# We could probably compute actual values for these using
# NSOpenGLPFAColorSize / 4 and NSOpenGLFAAccumSize / 4, but I'm not that
# confident I know what I'm doing.
_fake_gl_attributes = {
'red_size': 0,
'green_size': 0,
'blue_size': 0,
'accum_red_size': 0,
'accum_green_size': 0,
'accum_blue_size': 0,
'accum_alpha_size': 0
}
class CocoaConfig(Config):
def match(self, canvas):
# Construct array of attributes for NSOpenGLPixelFormat
attrs = []
for name, value in self.get_gl_attributes():
attr = _gl_attributes.get(name)
if not attr or not value:
continue
attrs.append(attr)
if attr not in _boolean_gl_attributes:
attrs.append(int(value))
# Support for RAGE-II, which is not compliant.
attrs.append(NSOpenGLPFAAllRenderers)
# Force selection policy.
attrs.append(NSOpenGLPFAMaximumPolicy)
# NSOpenGLPFAFullScreen is always supplied so we can switch to and
# from fullscreen without losing the context. Also must supply the
# NSOpenGLPFAScreenMask attribute with appropriate display ID.
# Note that these attributes aren't necessary to render in fullscreen
# on Mac OS X 10.6, because there we are simply rendering into a
# screen sized window. See:
# http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_fullscreen/opengl_cgl.html%23//apple_ref/doc/uid/TP40001987-CH210-SW6
attrs.append(NSOpenGLPFAFullScreen)
attrs.append(NSOpenGLPFAScreenMask)
attrs.append(quartz.CGDisplayIDToOpenGLDisplayMask(quartz.CGMainDisplayID()))
# Terminate the list.
attrs.append(0)
# Create the pixel format.
attrsArrayType = c_uint32 * len(attrs)
attrsArray = attrsArrayType(*attrs)
pixel_format = NSOpenGLPixelFormat.alloc().initWithAttributes_(attrsArray)
# Return the match list.
if pixel_format is None:
return []
else:
return [CocoaCanvasConfig(canvas, self, pixel_format)]
class CocoaCanvasConfig(CanvasConfig):
def __init__(self, canvas, config, pixel_format):
super(CocoaCanvasConfig, self).__init__(canvas, config)
self._pixel_format = pixel_format
# Query values for the attributes of the pixel format, and then set the
# corresponding attributes of the canvas config.
for name, attr in _gl_attributes.items():
vals = c_int()
self._pixel_format.getValues_forAttribute_forVirtualScreen_(byref(vals), attr, 0)
setattr(self, name, vals.value)
# Set these attributes so that we can run pyglet.info.
for name, value in _fake_gl_attributes.items():
setattr(self, name, value)
def create_context(self, share):
# Determine the shared NSOpenGLContext.
if share:
share_context = share._nscontext
else:
share_context = None
# Create a new NSOpenGLContext.
nscontext = NSOpenGLContext.alloc().initWithFormat_shareContext_(
self._pixel_format,
share_context)
return CocoaContext(self, nscontext, share)
def compatible(self, canvas):
return isinstance(canvas, CocoaCanvas)
class CocoaContext(Context):
def __init__(self, config, nscontext, share):
super(CocoaContext, self).__init__(config, share)
self.config = config
self._nscontext = nscontext
def attach(self, canvas):
super(CocoaContext, self).attach(canvas)
# The NSView instance should be attached to a nondeferred window before calling
# setView, otherwise you get an "invalid drawable" message.
self._nscontext.setView_(canvas.nsview)
self.set_current()
def detach(self):
super(CocoaContext, self).detach()
self._nscontext.clearDrawable()
def set_current(self):
self._nscontext.makeCurrentContext()
super(CocoaContext, self).set_current()
def update_geometry(self):
# Need to call this method whenever the context drawable (an NSView)
# changes size or location.
self._nscontext.update()
def set_full_screen(self):
self._nscontext.makeCurrentContext()
self._nscontext.setFullScreen()
def destroy(self):
super(CocoaContext, self).destroy()
self._nscontext.release()
self._nscontext = None
def set_vsync(self, vsync=True):
vals = c_int(vsync)
self._nscontext.setValues_forParameter_(byref(vals), NSOpenGLCPSwapInterval)
def get_vsync(self):
vals = c_int()
self._nscontext.getValues_forParameter_(byref(vals), NSOpenGLCPSwapInterval)
return vals.value
def flip(self):
self._nscontext.flushBuffer()
| Python |
#!/usr/bin/python
# $Id:$
from pyglet import gl, compat_platform
from pyglet.gl import gl_info
from pyglet.gl import glu_info
class Config(object):
'''Graphics configuration.
A Config stores the preferences for OpenGL attributes such as the
number of auxilliary buffers, size of the colour and depth buffers,
double buffering, stencilling, multi- and super-sampling, and so on.
Different platforms support a different set of attributes, so these
are set with a string key and a value which is integer or boolean.
:Ivariables:
`double_buffer` : bool
Specify the presence of a back-buffer for every color buffer.
`stereo` : bool
Specify the presence of separate left and right buffer sets.
`buffer_size` : int
Total bits per sample per color buffer.
`aux_buffers` : int
The number of auxilliary color buffers.
`sample_buffers` : int
The number of multisample buffers.
`samples` : int
The number of samples per pixel, or 0 if there are no multisample
buffers.
`red_size` : int
Bits per sample per buffer devoted to the red component.
`green_size` : int
Bits per sample per buffer devoted to the green component.
`blue_size` : int
Bits per sample per buffer devoted to the blue component.
`alpha_size` : int
Bits per sample per buffer devoted to the alpha component.
`depth_size` : int
Bits per sample in the depth buffer.
`stencil_size` : int
Bits per sample in the stencil buffer.
`accum_red_size` : int
Bits per pixel devoted to the red component in the accumulation
buffer.
`accum_green_size` : int
Bits per pixel devoted to the green component in the accumulation
buffer.
`accum_blue_size` : int
Bits per pixel devoted to the blue component in the accumulation
buffer.
`accum_alpha_size` : int
Bits per pixel devoted to the alpha component in the accumulation
buffer.
'''
_attribute_names = [
'double_buffer',
'stereo',
'buffer_size',
'aux_buffers',
'sample_buffers',
'samples',
'red_size',
'green_size',
'blue_size',
'alpha_size',
'depth_size',
'stencil_size',
'accum_red_size',
'accum_green_size',
'accum_blue_size',
'accum_alpha_size',
'major_version',
'minor_version',
'forward_compatible',
'debug'
]
major_version = None
minor_version = None
forward_compatible = None
debug = None
def __init__(self, **kwargs):
'''Create a template config with the given attributes.
Specify attributes as keyword arguments, for example::
template = Config(double_buffer=True)
'''
for name in self._attribute_names:
if name in kwargs:
setattr(self, name, kwargs[name])
else:
setattr(self, name, None)
def _requires_gl_3(self):
if self.major_version is not None and self.major_version >= 3:
return True
if self.forward_compatible or self.debug:
return True
return False
def get_gl_attributes(self):
'''Return a list of attributes set on this config.
:rtype: list of tuple (name, value)
:return: All attributes, with unset attributes having a value of
``None``.
'''
return [(name, getattr(self, name)) for name in self._attribute_names]
def match(self, canvas):
'''Return a list of matching complete configs for the given canvas.
:since: pyglet 1.2
:Parameters:
`canvas` : `Canvas`
Display to host contexts created from the config.
:rtype: list of `CanvasConfig`
'''
raise NotImplementedError('abstract')
def create_context(self, share):
'''Create a GL context that satisifies this configuration.
:deprecated: Use `CanvasConfig.create_context`.
:Parameters:
`share` : `Context`
If not None, a context with which to share objects with.
:rtype: `Context`
:return: The new context.
'''
raise gl.ConfigException(
'This config cannot be used to create contexts. '
'Use Config.match to created a CanvasConfig')
def is_complete(self):
'''Determine if this config is complete and able to create a context.
Configs created directly are not complete, they can only serve
as templates for retrieving a supported config from the system.
For example, `pyglet.window.Screen.get_matching_configs` returns
complete configs.
:deprecated: Use ``isinstance(config, CanvasConfig)``.
:rtype: bool
:return: True if the config is complete and can create a context.
'''
return isinstance(self, CanvasConfig)
def __repr__(self):
import pprint
return '%s(%s)' % (self.__class__.__name__,
pprint.pformat(self.get_gl_attributes()))
class CanvasConfig(Config):
'''OpenGL configuration for a particular canvas.
Use `Config.match` to obtain an instance of this class.
:since: pyglet 1.2
:Ivariables:
`canvas` : `Canvas`
The canvas this config is valid on.
'''
def __init__(self, canvas, base_config):
self.canvas = canvas
self.major_version = base_config.major_version
self.minor_version = base_config.minor_version
self.forward_compatible = base_config.forward_compatible
self.debug = base_config.debug
def compatible(self, canvas):
raise NotImplementedError('abstract')
def create_context(self, share):
'''Create a GL context that satisifies this configuration.
:Parameters:
`share` : `Context`
If not None, a context with which to share objects with.
:rtype: `Context`
:return: The new context.
'''
raise NotImplementedError('abstract')
def is_complete(self):
return True
class ObjectSpace(object):
def __init__(self):
# Textures and buffers scheduled for deletion the next time this
# object space is active.
self._doomed_textures = []
self._doomed_buffers = []
class Context(object):
'''OpenGL context for drawing.
Use `CanvasConfig.create_context` to create a context.
:Ivariables:
`object_space` : `ObjectSpace`
An object which is shared between all contexts that share
GL objects.
'''
#: Context share behaviour indicating that objects should not be
#: shared with existing contexts.
CONTEXT_SHARE_NONE = None
#: Context share behaviour indicating that objects are shared with
#: the most recently created context (the default).
CONTEXT_SHARE_EXISTING = 1
# Used for error checking, True if currently within a glBegin/End block.
# Ignored if error checking is disabled.
_gl_begin = False
# gl_info.GLInfo instance, filled in on first set_current
_info = None
# List of (attr, check) for each driver/device-specific workaround that is
# implemented. The `attr` attribute on this context is set to the result
# of evaluating `check(gl_info)` the first time this context is used.
_workaround_checks = [
# GDI Generic renderer on Windows does not implement
# GL_UNPACK_ROW_LENGTH correctly.
('_workaround_unpack_row_length',
lambda info: info.get_renderer() == 'GDI Generic'),
# Reportedly segfaults in text_input.py example with
# "ATI Radeon X1600 OpenGL Engine"
# glGenBuffers not exported by
# "ATI Radeon X1270 x86/MMX/3DNow!/SSE2"
# "RADEON XPRESS 200M Series x86/MMX/3DNow!/SSE2"
# glGenBuffers not exported by
# "Intel 965/963 Graphics Media Accelerator"
('_workaround_vbo',
lambda info: (info.get_renderer().startswith('ATI Radeon X')
or info.get_renderer().startswith('RADEON XPRESS 200M')
or info.get_renderer() ==
'Intel 965/963 Graphics Media Accelerator')),
# Some ATI cards on OS X start drawing from a VBO before it's written
# to. In these cases pyglet needs to call glFinish() to flush the
# pipeline after updating a buffer but before rendering.
('_workaround_vbo_finish',
lambda info: ('ATI' in info.get_renderer() and
info.have_version(1, 5) and
compat_platform == 'darwin')),
]
def __init__(self, config, context_share=None):
self.config = config
self.context_share = context_share
self.canvas = None
if context_share:
self.object_space = context_share.object_space
else:
self.object_space = ObjectSpace()
def __repr__(self):
return '%s()' % self.__class__.__name__
def attach(self, canvas):
if self.canvas is not None:
self.detach()
if not self.config.compatible(canvas):
raise RuntimeError('Cannot attach %r to %r' % (canvas, self))
self.canvas = canvas
def detach(self):
self.canvas = None
def set_current(self):
if not self.canvas:
raise RuntimeError('Canvas has not been attached')
# XXX not per-thread
gl.current_context = self
# XXX
gl_info.set_active_context()
glu_info.set_active_context()
# Implement workarounds
if not self._info:
self._info = gl_info.GLInfo()
self._info.set_active_context()
for attr, check in self._workaround_checks:
setattr(self, attr, check(self._info))
# Release textures and buffers on this context scheduled for deletion.
# Note that the garbage collector may introduce a race condition,
# so operate on a copy of the textures/buffers and remove the deleted
# items using list slicing (which is an atomic operation)
if self.object_space._doomed_textures:
textures = self.object_space._doomed_textures[:]
textures = (gl.GLuint * len(textures))(*textures)
gl.glDeleteTextures(len(textures), textures)
self.object_space._doomed_textures[0:len(textures)] = []
if self.object_space._doomed_buffers:
buffers = self.object_space._doomed_buffers[:]
buffers = (gl.GLuint * len(buffers))(*buffers)
gl.glDeleteBuffers(len(buffers), buffers)
self.object_space._doomed_buffers[0:len(buffers)] = []
def destroy(self):
'''Release the context.
The context will not be useable after being destroyed. Each platform
has its own convention for releasing the context and the buffer(s)
that depend on it in the correct order; this should never be called
by an application.
'''
self.detach()
if gl.current_context is self:
gl.current_context = None
gl_info.remove_active_context()
# Switch back to shadow context.
if gl._shadow_window is not None:
gl._shadow_window.switch_to()
def delete_texture(self, texture_id):
'''Safely delete a texture belonging to this context.
Usually, the texture is released immediately using
``glDeleteTextures``, however if another context that does not share
this context's object space is currently active, the deletion will
be deferred until an appropriate context is activated.
:Parameters:
`texture_id` : int
The OpenGL name of the texture to delete.
'''
if self.object_space is gl.current_context.object_space:
id = gl.GLuint(texture_id)
gl.glDeleteTextures(1, id)
else:
self.object_space._doomed_textures.append(texture_id)
def delete_buffer(self, buffer_id):
'''Safely delete a buffer object belonging to this context.
This method behaves similarly to `delete_texture`, though for
``glDeleteBuffers`` instead of ``glDeleteTextures``.
:Parameters:
`buffer_id` : int
The OpenGL name of the buffer to delete.
:since: pyglet 1.1
'''
if self.object_space is gl.current_context.object_space and False:
id = gl.GLuint(buffer_id)
gl.glDeleteBuffers(1, id)
else:
self.object_space._doomed_buffers.append(buffer_id)
def get_info(self):
'''Get the OpenGL information for this context.
:since: pyglet 1.2
:rtype: `GLInfo`
'''
return self._info
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Information about version and extensions of current GLU implementation.
Usage::
from pyglet.gl import glu_info
if glu_info.have_extension('GLU_EXT_nurbs_tessellator'):
# ...
If multiple contexts are in use you can use a separate GLUInfo object for each
context. Call `set_active_context` after switching to the desired context for
each GLUInfo::
from pyglet.gl.glu_info import GLUInfo
info = GLUInfo()
info.set_active_context()
if info.have_version(1, 3):
# ...
Note that GLUInfo only returns meaningful information if a context has been
created.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
import warnings
from pyglet.gl.glu import *
from pyglet.compat import asstr
class GLUInfo(object):
'''Information interface for the GLU library.
A default instance is created automatically when the first OpenGL context
is created. You can use the module functions as a convenience for
this default instance's methods.
If you are using more than one context, you must call `set_active_context`
when the context is active for this `GLUInfo` instance.
'''
have_context = False
version = '0.0.0'
extensions = []
_have_info = False
def set_active_context(self):
'''Store information for the currently active context.
This method is called automatically for the default context.
'''
self.have_context = True
if not self._have_info:
self.extensions = \
asstr(cast(gluGetString(GLU_EXTENSIONS), c_char_p).value).split()
self.version = asstr(cast(gluGetString(GLU_VERSION), c_char_p).value)
self._have_info = True
def have_version(self, major, minor=0, release=0):
'''Determine if a version of GLU is supported.
:Parameters:
`major` : int
The major revision number (typically 1).
`minor` : int
The minor revision number.
`release` : int
The release number.
:rtype: bool
:return: True if the requested or a later version is supported.
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
ver = '%s.0.0' % self.version.split(' ', 1)[0]
imajor, iminor, irelease = [int(v) for v in ver.split('.', 3)[:3]]
return imajor > major or \
(imajor == major and iminor > minor) or \
(imajor == major and iminor == minor and irelease >= release)
def get_version(self):
'''Get the current GLU version.
:return: the GLU version
:rtype: str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.version
def have_extension(self, extension):
'''Determine if a GLU extension is available.
:Parameters:
`extension` : str
The name of the extension to test for, including its
``GLU_`` prefix.
:return: True if the extension is provided by the implementation.
:rtype: bool
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return extension in self.extensions
def get_extensions(self):
'''Get a list of available GLU extensions.
:return: a list of the available extensions.
:rtype: list of str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.extensions
# Single instance useful for apps with only a single context (or all contexts
# have same GLU driver, common case).
_glu_info = GLUInfo()
set_active_context = _glu_info.set_active_context
have_version = _glu_info.have_version
get_version = _glu_info.get_version
have_extension = _glu_info.have_extension
get_extensions = _glu_info.get_extensions
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Cached information about version and extensions of current WGL
implementation.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: glx_info.py 615 2007-02-07 13:17:05Z Alex.Holkner $'
from ctypes import *
import warnings
from pyglet.gl.lib import MissingFunctionException
from pyglet.gl.gl import *
from pyglet.gl import gl_info
from pyglet.gl.wgl import *
from pyglet.gl.wglext_arb import *
from pyglet.compat import asstr
class WGLInfoException(Exception):
pass
class WGLInfo(object):
def get_extensions(self):
if not gl_info.have_context():
warnings.warn("Can't query WGL until a context is created.")
return []
try:
return asstr(wglGetExtensionsStringEXT()).split()
except MissingFunctionException:
return asstr(cast(glGetString(GL_EXTENSIONS), c_char_p).value).split()
def have_extension(self, extension):
return extension in self.get_extensions()
_wgl_info = WGLInfo()
get_extensions = _wgl_info.get_extensions
have_extension = _wgl_info.have_extension
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://developer.download.nvidia.com/opengl/includes/wglext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: gengl.py 601 2007-02-04 05:36:59Z Alex.Holkner $'
from ctypes import *
from pyglet.gl.lib import link_WGL as _link_function
from pyglet.gl.lib import c_ptrdiff_t, c_void
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for http://developer.download.nvidia.com/opengl/includes/wglext.h
# H (C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:7)
# H (C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:7)
WIN32_LEAN_AND_MEAN = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:40
WGL_WGLEXT_VERSION = 6 # http://developer.download.nvidia.com/opengl/includes/wglext.h:60
# ARB_buffer_region (http://developer.download.nvidia.com/opengl/includes/wglext.h:62)
WGL_FRONT_COLOR_BUFFER_BIT_ARB = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:63
WGL_BACK_COLOR_BUFFER_BIT_ARB = 2 # http://developer.download.nvidia.com/opengl/includes/wglext.h:64
WGL_DEPTH_BUFFER_BIT_ARB = 4 # http://developer.download.nvidia.com/opengl/includes/wglext.h:65
WGL_STENCIL_BUFFER_BIT_ARB = 8 # http://developer.download.nvidia.com/opengl/includes/wglext.h:66
# ARB_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:69)
WGL_SAMPLE_BUFFERS_ARB = 8257 # http://developer.download.nvidia.com/opengl/includes/wglext.h:70
WGL_SAMPLES_ARB = 8258 # http://developer.download.nvidia.com/opengl/includes/wglext.h:71
# ARB_extensions_string (http://developer.download.nvidia.com/opengl/includes/wglext.h:74)
# ARB_pixel_format (http://developer.download.nvidia.com/opengl/includes/wglext.h:77)
WGL_NUMBER_PIXEL_FORMATS_ARB = 8192 # http://developer.download.nvidia.com/opengl/includes/wglext.h:78
WGL_DRAW_TO_WINDOW_ARB = 8193 # http://developer.download.nvidia.com/opengl/includes/wglext.h:79
WGL_DRAW_TO_BITMAP_ARB = 8194 # http://developer.download.nvidia.com/opengl/includes/wglext.h:80
WGL_ACCELERATION_ARB = 8195 # http://developer.download.nvidia.com/opengl/includes/wglext.h:81
WGL_NEED_PALETTE_ARB = 8196 # http://developer.download.nvidia.com/opengl/includes/wglext.h:82
WGL_NEED_SYSTEM_PALETTE_ARB = 8197 # http://developer.download.nvidia.com/opengl/includes/wglext.h:83
WGL_SWAP_LAYER_BUFFERS_ARB = 8198 # http://developer.download.nvidia.com/opengl/includes/wglext.h:84
WGL_SWAP_METHOD_ARB = 8199 # http://developer.download.nvidia.com/opengl/includes/wglext.h:85
WGL_NUMBER_OVERLAYS_ARB = 8200 # http://developer.download.nvidia.com/opengl/includes/wglext.h:86
WGL_NUMBER_UNDERLAYS_ARB = 8201 # http://developer.download.nvidia.com/opengl/includes/wglext.h:87
WGL_TRANSPARENT_ARB = 8202 # http://developer.download.nvidia.com/opengl/includes/wglext.h:88
WGL_TRANSPARENT_RED_VALUE_ARB = 8247 # http://developer.download.nvidia.com/opengl/includes/wglext.h:89
WGL_TRANSPARENT_GREEN_VALUE_ARB = 8248 # http://developer.download.nvidia.com/opengl/includes/wglext.h:90
WGL_TRANSPARENT_BLUE_VALUE_ARB = 8249 # http://developer.download.nvidia.com/opengl/includes/wglext.h:91
WGL_TRANSPARENT_ALPHA_VALUE_ARB = 8250 # http://developer.download.nvidia.com/opengl/includes/wglext.h:92
WGL_TRANSPARENT_INDEX_VALUE_ARB = 8251 # http://developer.download.nvidia.com/opengl/includes/wglext.h:93
WGL_SHARE_DEPTH_ARB = 8204 # http://developer.download.nvidia.com/opengl/includes/wglext.h:94
WGL_SHARE_STENCIL_ARB = 8205 # http://developer.download.nvidia.com/opengl/includes/wglext.h:95
WGL_SHARE_ACCUM_ARB = 8206 # http://developer.download.nvidia.com/opengl/includes/wglext.h:96
WGL_SUPPORT_GDI_ARB = 8207 # http://developer.download.nvidia.com/opengl/includes/wglext.h:97
WGL_SUPPORT_OPENGL_ARB = 8208 # http://developer.download.nvidia.com/opengl/includes/wglext.h:98
WGL_DOUBLE_BUFFER_ARB = 8209 # http://developer.download.nvidia.com/opengl/includes/wglext.h:99
WGL_STEREO_ARB = 8210 # http://developer.download.nvidia.com/opengl/includes/wglext.h:100
WGL_PIXEL_TYPE_ARB = 8211 # http://developer.download.nvidia.com/opengl/includes/wglext.h:101
WGL_COLOR_BITS_ARB = 8212 # http://developer.download.nvidia.com/opengl/includes/wglext.h:102
WGL_RED_BITS_ARB = 8213 # http://developer.download.nvidia.com/opengl/includes/wglext.h:103
WGL_RED_SHIFT_ARB = 8214 # http://developer.download.nvidia.com/opengl/includes/wglext.h:104
WGL_GREEN_BITS_ARB = 8215 # http://developer.download.nvidia.com/opengl/includes/wglext.h:105
WGL_GREEN_SHIFT_ARB = 8216 # http://developer.download.nvidia.com/opengl/includes/wglext.h:106
WGL_BLUE_BITS_ARB = 8217 # http://developer.download.nvidia.com/opengl/includes/wglext.h:107
WGL_BLUE_SHIFT_ARB = 8218 # http://developer.download.nvidia.com/opengl/includes/wglext.h:108
WGL_ALPHA_BITS_ARB = 8219 # http://developer.download.nvidia.com/opengl/includes/wglext.h:109
WGL_ALPHA_SHIFT_ARB = 8220 # http://developer.download.nvidia.com/opengl/includes/wglext.h:110
WGL_ACCUM_BITS_ARB = 8221 # http://developer.download.nvidia.com/opengl/includes/wglext.h:111
WGL_ACCUM_RED_BITS_ARB = 8222 # http://developer.download.nvidia.com/opengl/includes/wglext.h:112
WGL_ACCUM_GREEN_BITS_ARB = 8223 # http://developer.download.nvidia.com/opengl/includes/wglext.h:113
WGL_ACCUM_BLUE_BITS_ARB = 8224 # http://developer.download.nvidia.com/opengl/includes/wglext.h:114
WGL_ACCUM_ALPHA_BITS_ARB = 8225 # http://developer.download.nvidia.com/opengl/includes/wglext.h:115
WGL_DEPTH_BITS_ARB = 8226 # http://developer.download.nvidia.com/opengl/includes/wglext.h:116
WGL_STENCIL_BITS_ARB = 8227 # http://developer.download.nvidia.com/opengl/includes/wglext.h:117
WGL_AUX_BUFFERS_ARB = 8228 # http://developer.download.nvidia.com/opengl/includes/wglext.h:118
WGL_NO_ACCELERATION_ARB = 8229 # http://developer.download.nvidia.com/opengl/includes/wglext.h:119
WGL_GENERIC_ACCELERATION_ARB = 8230 # http://developer.download.nvidia.com/opengl/includes/wglext.h:120
WGL_FULL_ACCELERATION_ARB = 8231 # http://developer.download.nvidia.com/opengl/includes/wglext.h:121
WGL_SWAP_EXCHANGE_ARB = 8232 # http://developer.download.nvidia.com/opengl/includes/wglext.h:122
WGL_SWAP_COPY_ARB = 8233 # http://developer.download.nvidia.com/opengl/includes/wglext.h:123
WGL_SWAP_UNDEFINED_ARB = 8234 # http://developer.download.nvidia.com/opengl/includes/wglext.h:124
WGL_TYPE_RGBA_ARB = 8235 # http://developer.download.nvidia.com/opengl/includes/wglext.h:125
WGL_TYPE_COLORINDEX_ARB = 8236 # http://developer.download.nvidia.com/opengl/includes/wglext.h:126
# ARB_make_current_read (http://developer.download.nvidia.com/opengl/includes/wglext.h:129)
ERROR_INVALID_PIXEL_TYPE_ARB = 8259 # http://developer.download.nvidia.com/opengl/includes/wglext.h:130
ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 8276 # http://developer.download.nvidia.com/opengl/includes/wglext.h:131
# ARB_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:134)
WGL_DRAW_TO_PBUFFER_ARB = 8237 # http://developer.download.nvidia.com/opengl/includes/wglext.h:135
WGL_MAX_PBUFFER_PIXELS_ARB = 8238 # http://developer.download.nvidia.com/opengl/includes/wglext.h:136
WGL_MAX_PBUFFER_WIDTH_ARB = 8239 # http://developer.download.nvidia.com/opengl/includes/wglext.h:137
WGL_MAX_PBUFFER_HEIGHT_ARB = 8240 # http://developer.download.nvidia.com/opengl/includes/wglext.h:138
WGL_PBUFFER_LARGEST_ARB = 8243 # http://developer.download.nvidia.com/opengl/includes/wglext.h:139
WGL_PBUFFER_WIDTH_ARB = 8244 # http://developer.download.nvidia.com/opengl/includes/wglext.h:140
WGL_PBUFFER_HEIGHT_ARB = 8245 # http://developer.download.nvidia.com/opengl/includes/wglext.h:141
WGL_PBUFFER_LOST_ARB = 8246 # http://developer.download.nvidia.com/opengl/includes/wglext.h:142
# ARB_render_texture (http://developer.download.nvidia.com/opengl/includes/wglext.h:145)
WGL_BIND_TO_TEXTURE_RGB_ARB = 8304 # http://developer.download.nvidia.com/opengl/includes/wglext.h:146
WGL_BIND_TO_TEXTURE_RGBA_ARB = 8305 # http://developer.download.nvidia.com/opengl/includes/wglext.h:147
WGL_TEXTURE_FORMAT_ARB = 8306 # http://developer.download.nvidia.com/opengl/includes/wglext.h:148
WGL_TEXTURE_TARGET_ARB = 8307 # http://developer.download.nvidia.com/opengl/includes/wglext.h:149
WGL_MIPMAP_TEXTURE_ARB = 8308 # http://developer.download.nvidia.com/opengl/includes/wglext.h:150
WGL_TEXTURE_RGB_ARB = 8309 # http://developer.download.nvidia.com/opengl/includes/wglext.h:151
WGL_TEXTURE_RGBA_ARB = 8310 # http://developer.download.nvidia.com/opengl/includes/wglext.h:152
WGL_NO_TEXTURE_ARB = 8311 # http://developer.download.nvidia.com/opengl/includes/wglext.h:153
WGL_TEXTURE_CUBE_MAP_ARB = 8312 # http://developer.download.nvidia.com/opengl/includes/wglext.h:154
WGL_TEXTURE_1D_ARB = 8313 # http://developer.download.nvidia.com/opengl/includes/wglext.h:155
WGL_TEXTURE_2D_ARB = 8314 # http://developer.download.nvidia.com/opengl/includes/wglext.h:156
WGL_MIPMAP_LEVEL_ARB = 8315 # http://developer.download.nvidia.com/opengl/includes/wglext.h:157
WGL_CUBE_MAP_FACE_ARB = 8316 # http://developer.download.nvidia.com/opengl/includes/wglext.h:158
WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 8317 # http://developer.download.nvidia.com/opengl/includes/wglext.h:159
WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 8318 # http://developer.download.nvidia.com/opengl/includes/wglext.h:160
WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 8319 # http://developer.download.nvidia.com/opengl/includes/wglext.h:161
WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 8320 # http://developer.download.nvidia.com/opengl/includes/wglext.h:162
WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 8321 # http://developer.download.nvidia.com/opengl/includes/wglext.h:163
WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 8322 # http://developer.download.nvidia.com/opengl/includes/wglext.h:164
WGL_FRONT_LEFT_ARB = 8323 # http://developer.download.nvidia.com/opengl/includes/wglext.h:165
WGL_FRONT_RIGHT_ARB = 8324 # http://developer.download.nvidia.com/opengl/includes/wglext.h:166
WGL_BACK_LEFT_ARB = 8325 # http://developer.download.nvidia.com/opengl/includes/wglext.h:167
WGL_BACK_RIGHT_ARB = 8326 # http://developer.download.nvidia.com/opengl/includes/wglext.h:168
WGL_AUX0_ARB = 8327 # http://developer.download.nvidia.com/opengl/includes/wglext.h:169
WGL_AUX1_ARB = 8328 # http://developer.download.nvidia.com/opengl/includes/wglext.h:170
WGL_AUX2_ARB = 8329 # http://developer.download.nvidia.com/opengl/includes/wglext.h:171
WGL_AUX3_ARB = 8330 # http://developer.download.nvidia.com/opengl/includes/wglext.h:172
WGL_AUX4_ARB = 8331 # http://developer.download.nvidia.com/opengl/includes/wglext.h:173
WGL_AUX5_ARB = 8332 # http://developer.download.nvidia.com/opengl/includes/wglext.h:174
WGL_AUX6_ARB = 8333 # http://developer.download.nvidia.com/opengl/includes/wglext.h:175
WGL_AUX7_ARB = 8334 # http://developer.download.nvidia.com/opengl/includes/wglext.h:176
WGL_AUX8_ARB = 8335 # http://developer.download.nvidia.com/opengl/includes/wglext.h:177
WGL_AUX9_ARB = 8336 # http://developer.download.nvidia.com/opengl/includes/wglext.h:178
# ARB_pixel_format_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:181)
WGL_TYPE_RGBA_FLOAT_ARB = 8608 # http://developer.download.nvidia.com/opengl/includes/wglext.h:182
# EXT_make_current_read (http://developer.download.nvidia.com/opengl/includes/wglext.h:185)
ERROR_INVALID_PIXEL_TYPE_EXT = 8259 # http://developer.download.nvidia.com/opengl/includes/wglext.h:186
# EXT_pixel_format (http://developer.download.nvidia.com/opengl/includes/wglext.h:189)
WGL_NUMBER_PIXEL_FORMATS_EXT = 8192 # http://developer.download.nvidia.com/opengl/includes/wglext.h:190
WGL_DRAW_TO_WINDOW_EXT = 8193 # http://developer.download.nvidia.com/opengl/includes/wglext.h:191
WGL_DRAW_TO_BITMAP_EXT = 8194 # http://developer.download.nvidia.com/opengl/includes/wglext.h:192
WGL_ACCELERATION_EXT = 8195 # http://developer.download.nvidia.com/opengl/includes/wglext.h:193
WGL_NEED_PALETTE_EXT = 8196 # http://developer.download.nvidia.com/opengl/includes/wglext.h:194
WGL_NEED_SYSTEM_PALETTE_EXT = 8197 # http://developer.download.nvidia.com/opengl/includes/wglext.h:195
WGL_SWAP_LAYER_BUFFERS_EXT = 8198 # http://developer.download.nvidia.com/opengl/includes/wglext.h:196
WGL_SWAP_METHOD_EXT = 8199 # http://developer.download.nvidia.com/opengl/includes/wglext.h:197
WGL_NUMBER_OVERLAYS_EXT = 8200 # http://developer.download.nvidia.com/opengl/includes/wglext.h:198
WGL_NUMBER_UNDERLAYS_EXT = 8201 # http://developer.download.nvidia.com/opengl/includes/wglext.h:199
WGL_TRANSPARENT_EXT = 8202 # http://developer.download.nvidia.com/opengl/includes/wglext.h:200
WGL_TRANSPARENT_VALUE_EXT = 8203 # http://developer.download.nvidia.com/opengl/includes/wglext.h:201
WGL_SHARE_DEPTH_EXT = 8204 # http://developer.download.nvidia.com/opengl/includes/wglext.h:202
WGL_SHARE_STENCIL_EXT = 8205 # http://developer.download.nvidia.com/opengl/includes/wglext.h:203
WGL_SHARE_ACCUM_EXT = 8206 # http://developer.download.nvidia.com/opengl/includes/wglext.h:204
WGL_SUPPORT_GDI_EXT = 8207 # http://developer.download.nvidia.com/opengl/includes/wglext.h:205
WGL_SUPPORT_OPENGL_EXT = 8208 # http://developer.download.nvidia.com/opengl/includes/wglext.h:206
WGL_DOUBLE_BUFFER_EXT = 8209 # http://developer.download.nvidia.com/opengl/includes/wglext.h:207
WGL_STEREO_EXT = 8210 # http://developer.download.nvidia.com/opengl/includes/wglext.h:208
WGL_PIXEL_TYPE_EXT = 8211 # http://developer.download.nvidia.com/opengl/includes/wglext.h:209
WGL_COLOR_BITS_EXT = 8212 # http://developer.download.nvidia.com/opengl/includes/wglext.h:210
WGL_RED_BITS_EXT = 8213 # http://developer.download.nvidia.com/opengl/includes/wglext.h:211
WGL_RED_SHIFT_EXT = 8214 # http://developer.download.nvidia.com/opengl/includes/wglext.h:212
WGL_GREEN_BITS_EXT = 8215 # http://developer.download.nvidia.com/opengl/includes/wglext.h:213
WGL_GREEN_SHIFT_EXT = 8216 # http://developer.download.nvidia.com/opengl/includes/wglext.h:214
WGL_BLUE_BITS_EXT = 8217 # http://developer.download.nvidia.com/opengl/includes/wglext.h:215
WGL_BLUE_SHIFT_EXT = 8218 # http://developer.download.nvidia.com/opengl/includes/wglext.h:216
WGL_ALPHA_BITS_EXT = 8219 # http://developer.download.nvidia.com/opengl/includes/wglext.h:217
WGL_ALPHA_SHIFT_EXT = 8220 # http://developer.download.nvidia.com/opengl/includes/wglext.h:218
WGL_ACCUM_BITS_EXT = 8221 # http://developer.download.nvidia.com/opengl/includes/wglext.h:219
WGL_ACCUM_RED_BITS_EXT = 8222 # http://developer.download.nvidia.com/opengl/includes/wglext.h:220
WGL_ACCUM_GREEN_BITS_EXT = 8223 # http://developer.download.nvidia.com/opengl/includes/wglext.h:221
WGL_ACCUM_BLUE_BITS_EXT = 8224 # http://developer.download.nvidia.com/opengl/includes/wglext.h:222
WGL_ACCUM_ALPHA_BITS_EXT = 8225 # http://developer.download.nvidia.com/opengl/includes/wglext.h:223
WGL_DEPTH_BITS_EXT = 8226 # http://developer.download.nvidia.com/opengl/includes/wglext.h:224
WGL_STENCIL_BITS_EXT = 8227 # http://developer.download.nvidia.com/opengl/includes/wglext.h:225
WGL_AUX_BUFFERS_EXT = 8228 # http://developer.download.nvidia.com/opengl/includes/wglext.h:226
WGL_NO_ACCELERATION_EXT = 8229 # http://developer.download.nvidia.com/opengl/includes/wglext.h:227
WGL_GENERIC_ACCELERATION_EXT = 8230 # http://developer.download.nvidia.com/opengl/includes/wglext.h:228
WGL_FULL_ACCELERATION_EXT = 8231 # http://developer.download.nvidia.com/opengl/includes/wglext.h:229
WGL_SWAP_EXCHANGE_EXT = 8232 # http://developer.download.nvidia.com/opengl/includes/wglext.h:230
WGL_SWAP_COPY_EXT = 8233 # http://developer.download.nvidia.com/opengl/includes/wglext.h:231
WGL_SWAP_UNDEFINED_EXT = 8234 # http://developer.download.nvidia.com/opengl/includes/wglext.h:232
WGL_TYPE_RGBA_EXT = 8235 # http://developer.download.nvidia.com/opengl/includes/wglext.h:233
WGL_TYPE_COLORINDEX_EXT = 8236 # http://developer.download.nvidia.com/opengl/includes/wglext.h:234
# EXT_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:237)
WGL_DRAW_TO_PBUFFER_EXT = 8237 # http://developer.download.nvidia.com/opengl/includes/wglext.h:238
WGL_MAX_PBUFFER_PIXELS_EXT = 8238 # http://developer.download.nvidia.com/opengl/includes/wglext.h:239
WGL_MAX_PBUFFER_WIDTH_EXT = 8239 # http://developer.download.nvidia.com/opengl/includes/wglext.h:240
WGL_MAX_PBUFFER_HEIGHT_EXT = 8240 # http://developer.download.nvidia.com/opengl/includes/wglext.h:241
WGL_OPTIMAL_PBUFFER_WIDTH_EXT = 8241 # http://developer.download.nvidia.com/opengl/includes/wglext.h:242
WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = 8242 # http://developer.download.nvidia.com/opengl/includes/wglext.h:243
WGL_PBUFFER_LARGEST_EXT = 8243 # http://developer.download.nvidia.com/opengl/includes/wglext.h:244
WGL_PBUFFER_WIDTH_EXT = 8244 # http://developer.download.nvidia.com/opengl/includes/wglext.h:245
WGL_PBUFFER_HEIGHT_EXT = 8245 # http://developer.download.nvidia.com/opengl/includes/wglext.h:246
# EXT_depth_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:249)
WGL_DEPTH_FLOAT_EXT = 8256 # http://developer.download.nvidia.com/opengl/includes/wglext.h:250
# 3DFX_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:253)
WGL_SAMPLE_BUFFERS_3DFX = 8288 # http://developer.download.nvidia.com/opengl/includes/wglext.h:254
WGL_SAMPLES_3DFX = 8289 # http://developer.download.nvidia.com/opengl/includes/wglext.h:255
# EXT_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:258)
WGL_SAMPLE_BUFFERS_EXT = 8257 # http://developer.download.nvidia.com/opengl/includes/wglext.h:259
WGL_SAMPLES_EXT = 8258 # http://developer.download.nvidia.com/opengl/includes/wglext.h:260
# I3D_digital_video_control (http://developer.download.nvidia.com/opengl/includes/wglext.h:263)
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 8272 # http://developer.download.nvidia.com/opengl/includes/wglext.h:264
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 8273 # http://developer.download.nvidia.com/opengl/includes/wglext.h:265
WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 8274 # http://developer.download.nvidia.com/opengl/includes/wglext.h:266
WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 8275 # http://developer.download.nvidia.com/opengl/includes/wglext.h:267
# I3D_gamma (http://developer.download.nvidia.com/opengl/includes/wglext.h:270)
WGL_GAMMA_TABLE_SIZE_I3D = 8270 # http://developer.download.nvidia.com/opengl/includes/wglext.h:271
WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 8271 # http://developer.download.nvidia.com/opengl/includes/wglext.h:272
# I3D_genlock (http://developer.download.nvidia.com/opengl/includes/wglext.h:275)
WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = 8260 # http://developer.download.nvidia.com/opengl/includes/wglext.h:276
WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = 8261 # http://developer.download.nvidia.com/opengl/includes/wglext.h:277
WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = 8262 # http://developer.download.nvidia.com/opengl/includes/wglext.h:278
WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = 8263 # http://developer.download.nvidia.com/opengl/includes/wglext.h:279
WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 8264 # http://developer.download.nvidia.com/opengl/includes/wglext.h:280
WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 8265 # http://developer.download.nvidia.com/opengl/includes/wglext.h:281
WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = 8266 # http://developer.download.nvidia.com/opengl/includes/wglext.h:282
WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = 8267 # http://developer.download.nvidia.com/opengl/includes/wglext.h:283
WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = 8268 # http://developer.download.nvidia.com/opengl/includes/wglext.h:284
# I3D_image_buffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:287)
WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:288
WGL_IMAGE_BUFFER_LOCK_I3D = 2 # http://developer.download.nvidia.com/opengl/includes/wglext.h:289
# I3D_swap_frame_lock (http://developer.download.nvidia.com/opengl/includes/wglext.h:292)
# NV_render_depth_texture (http://developer.download.nvidia.com/opengl/includes/wglext.h:295)
WGL_BIND_TO_TEXTURE_DEPTH_NV = 8355 # http://developer.download.nvidia.com/opengl/includes/wglext.h:296
WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 8356 # http://developer.download.nvidia.com/opengl/includes/wglext.h:297
WGL_DEPTH_TEXTURE_FORMAT_NV = 8357 # http://developer.download.nvidia.com/opengl/includes/wglext.h:298
WGL_TEXTURE_DEPTH_COMPONENT_NV = 8358 # http://developer.download.nvidia.com/opengl/includes/wglext.h:299
WGL_DEPTH_COMPONENT_NV = 8359 # http://developer.download.nvidia.com/opengl/includes/wglext.h:300
# NV_render_texture_rectangle (http://developer.download.nvidia.com/opengl/includes/wglext.h:303)
WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 8352 # http://developer.download.nvidia.com/opengl/includes/wglext.h:304
WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 8353 # http://developer.download.nvidia.com/opengl/includes/wglext.h:305
WGL_TEXTURE_RECTANGLE_NV = 8354 # http://developer.download.nvidia.com/opengl/includes/wglext.h:306
# ATI_pixel_format_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:309)
WGL_TYPE_RGBA_FLOAT_ATI = 8608 # http://developer.download.nvidia.com/opengl/includes/wglext.h:310
WGL_RGBA_FLOAT_MODE_ATI = 34848 # http://developer.download.nvidia.com/opengl/includes/wglext.h:311
WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 34869 # http://developer.download.nvidia.com/opengl/includes/wglext.h:312
# NV_float_buffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:315)
WGL_FLOAT_COMPONENTS_NV = 8368 # http://developer.download.nvidia.com/opengl/includes/wglext.h:316
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 8369 # http://developer.download.nvidia.com/opengl/includes/wglext.h:317
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 8370 # http://developer.download.nvidia.com/opengl/includes/wglext.h:318
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 8371 # http://developer.download.nvidia.com/opengl/includes/wglext.h:319
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 8372 # http://developer.download.nvidia.com/opengl/includes/wglext.h:320
WGL_TEXTURE_FLOAT_R_NV = 8373 # http://developer.download.nvidia.com/opengl/includes/wglext.h:321
WGL_TEXTURE_FLOAT_RG_NV = 8374 # http://developer.download.nvidia.com/opengl/includes/wglext.h:322
WGL_TEXTURE_FLOAT_RGB_NV = 8375 # http://developer.download.nvidia.com/opengl/includes/wglext.h:323
WGL_TEXTURE_FLOAT_RGBA_NV = 8376 # http://developer.download.nvidia.com/opengl/includes/wglext.h:324
# NV_swap_group (http://developer.download.nvidia.com/opengl/includes/wglext.h:327)
# NV_gpu_affinity (http://developer.download.nvidia.com/opengl/includes/wglext.h:330)
WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 8400 # http://developer.download.nvidia.com/opengl/includes/wglext.h:331
WGL_ERROR_MISSING_AFFINITY_MASK_NV = 8401 # http://developer.download.nvidia.com/opengl/includes/wglext.h:332
# ARB_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:338)
HANDLE = POINTER(None) # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:58
HPBUFFERARB = HANDLE # http://developer.download.nvidia.com/opengl/includes/wglext.h:339
# EXT_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:341)
HPBUFFEREXT = HANDLE # http://developer.download.nvidia.com/opengl/includes/wglext.h:342
# NV_gpu_affinity (http://developer.download.nvidia.com/opengl/includes/wglext.h:345)
HGPUNV = HANDLE # http://developer.download.nvidia.com/opengl/includes/wglext.h:346
class struct__GPU_DEVICE(Structure):
__slots__ = [
'cb',
'DeviceName',
'DeviceString',
'Flags',
'rcVirtualScreen',
]
DWORD = c_ulong # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:54
CHAR = c_char # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:47
class struct_tagRECT(Structure):
__slots__ = [
'left',
'top',
'right',
'bottom',
]
LONG = c_long # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:53
struct_tagRECT._fields_ = [
('left', LONG),
('top', LONG),
('right', LONG),
('bottom', LONG),
]
RECT = struct_tagRECT # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:200
struct__GPU_DEVICE._fields_ = [
('cb', DWORD),
('DeviceName', CHAR * 32),
('DeviceString', CHAR * 128),
('Flags', DWORD),
('rcVirtualScreen', RECT),
]
GPU_DEVICE = struct__GPU_DEVICE # http://developer.download.nvidia.com/opengl/includes/wglext.h:353
PGPU_DEVICE = POINTER(struct__GPU_DEVICE) # http://developer.download.nvidia.com/opengl/includes/wglext.h:353
# ARB_buffer_region (http://developer.download.nvidia.com/opengl/includes/wglext.h:356)
WGL_ARB_buffer_region = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:357
HDC = HANDLE # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:61
UINT = c_uint # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:50
# http://developer.download.nvidia.com/opengl/includes/wglext.h:359
wglCreateBufferRegionARB = _link_function('wglCreateBufferRegionARB', HANDLE, [HDC, c_int, UINT], 'ARB_buffer_region')
VOID = None # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:45
# http://developer.download.nvidia.com/opengl/includes/wglext.h:360
wglDeleteBufferRegionARB = _link_function('wglDeleteBufferRegionARB', VOID, [HANDLE], 'ARB_buffer_region')
BOOL = c_long # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:52
# http://developer.download.nvidia.com/opengl/includes/wglext.h:361
wglSaveBufferRegionARB = _link_function('wglSaveBufferRegionARB', BOOL, [HANDLE, c_int, c_int, c_int, c_int], 'ARB_buffer_region')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:362
wglRestoreBufferRegionARB = _link_function('wglRestoreBufferRegionARB', BOOL, [HANDLE, c_int, c_int, c_int, c_int, c_int, c_int], 'ARB_buffer_region')
PFNWGLCREATEBUFFERREGIONARBPROC = CFUNCTYPE(HANDLE, HDC, c_int, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:364
PFNWGLDELETEBUFFERREGIONARBPROC = CFUNCTYPE(VOID, HANDLE) # http://developer.download.nvidia.com/opengl/includes/wglext.h:365
PFNWGLSAVEBUFFERREGIONARBPROC = CFUNCTYPE(BOOL, HANDLE, c_int, c_int, c_int, c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:366
PFNWGLRESTOREBUFFERREGIONARBPROC = CFUNCTYPE(BOOL, HANDLE, c_int, c_int, c_int, c_int, c_int, c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:367
# ARB_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:370)
WGL_ARB_multisample = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:371
# ARB_extensions_string (http://developer.download.nvidia.com/opengl/includes/wglext.h:374)
WGL_ARB_extensions_string = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:375
# http://developer.download.nvidia.com/opengl/includes/wglext.h:377
wglGetExtensionsStringARB = _link_function('wglGetExtensionsStringARB', c_char_p, [HDC], 'ARB_extensions_string')
PFNWGLGETEXTENSIONSSTRINGARBPROC = CFUNCTYPE(c_char_p, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:379
# ARB_pixel_format (http://developer.download.nvidia.com/opengl/includes/wglext.h:382)
WGL_ARB_pixel_format = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:383
# http://developer.download.nvidia.com/opengl/includes/wglext.h:385
wglGetPixelFormatAttribivARB = _link_function('wglGetPixelFormatAttribivARB', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)], 'ARB_pixel_format')
FLOAT = c_float # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:55
# http://developer.download.nvidia.com/opengl/includes/wglext.h:386
wglGetPixelFormatAttribfvARB = _link_function('wglGetPixelFormatAttribfvARB', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)], 'ARB_pixel_format')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:387
wglChoosePixelFormatARB = _link_function('wglChoosePixelFormatARB', BOOL, [HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)], 'ARB_pixel_format')
PFNWGLGETPIXELFORMATATTRIBIVARBPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:389
PFNWGLGETPIXELFORMATATTRIBFVARBPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:390
PFNWGLCHOOSEPIXELFORMATARBPROC = CFUNCTYPE(BOOL, HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:391
# ARB_make_current_read (http://developer.download.nvidia.com/opengl/includes/wglext.h:394)
WGL_ARB_make_current_read = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:395
HGLRC = HANDLE # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:60
# http://developer.download.nvidia.com/opengl/includes/wglext.h:397
wglMakeContextCurrentARB = _link_function('wglMakeContextCurrentARB', BOOL, [HDC, HDC, HGLRC], 'ARB_make_current_read')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:398
wglGetCurrentReadDCARB = _link_function('wglGetCurrentReadDCARB', HDC, [], 'ARB_make_current_read')
PFNWGLMAKECONTEXTCURRENTARBPROC = CFUNCTYPE(BOOL, HDC, HDC, HGLRC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:400
PFNWGLGETCURRENTREADDCARBPROC = CFUNCTYPE(HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:401
# ARB_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:404)
WGL_ARB_pbuffer = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:405
# http://developer.download.nvidia.com/opengl/includes/wglext.h:407
wglCreatePbufferARB = _link_function('wglCreatePbufferARB', HPBUFFERARB, [HDC, c_int, c_int, c_int, POINTER(c_int)], 'ARB_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:408
wglGetPbufferDCARB = _link_function('wglGetPbufferDCARB', HDC, [HPBUFFERARB], 'ARB_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:409
wglReleasePbufferDCARB = _link_function('wglReleasePbufferDCARB', c_int, [HPBUFFERARB, HDC], 'ARB_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:410
wglDestroyPbufferARB = _link_function('wglDestroyPbufferARB', BOOL, [HPBUFFERARB], 'ARB_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:411
wglQueryPbufferARB = _link_function('wglQueryPbufferARB', BOOL, [HPBUFFERARB, c_int, POINTER(c_int)], 'ARB_pbuffer')
PFNWGLCREATEPBUFFERARBPROC = CFUNCTYPE(HPBUFFERARB, HDC, c_int, c_int, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:413
PFNWGLGETPBUFFERDCARBPROC = CFUNCTYPE(HDC, HPBUFFERARB) # http://developer.download.nvidia.com/opengl/includes/wglext.h:414
PFNWGLRELEASEPBUFFERDCARBPROC = CFUNCTYPE(c_int, HPBUFFERARB, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:415
PFNWGLDESTROYPBUFFERARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB) # http://developer.download.nvidia.com/opengl/includes/wglext.h:416
PFNWGLQUERYPBUFFERARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:417
# ARB_render_texture (http://developer.download.nvidia.com/opengl/includes/wglext.h:420)
WGL_ARB_render_texture = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:421
# http://developer.download.nvidia.com/opengl/includes/wglext.h:423
wglBindTexImageARB = _link_function('wglBindTexImageARB', BOOL, [HPBUFFERARB, c_int], 'ARB_render_texture')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:424
wglReleaseTexImageARB = _link_function('wglReleaseTexImageARB', BOOL, [HPBUFFERARB, c_int], 'ARB_render_texture')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:425
wglSetPbufferAttribARB = _link_function('wglSetPbufferAttribARB', BOOL, [HPBUFFERARB, POINTER(c_int)], 'ARB_render_texture')
PFNWGLBINDTEXIMAGEARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:427
PFNWGLRELEASETEXIMAGEARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:428
PFNWGLSETPBUFFERATTRIBARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:429
# ARB_pixel_format_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:432)
WGL_ARB_pixel_format_float = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:433
# EXT_display_color_table (http://developer.download.nvidia.com/opengl/includes/wglext.h:436)
WGL_EXT_display_color_table = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:437
GLboolean = c_ubyte # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:18
GLushort = c_ushort # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:25
# http://developer.download.nvidia.com/opengl/includes/wglext.h:439
wglCreateDisplayColorTableEXT = _link_function('wglCreateDisplayColorTableEXT', GLboolean, [GLushort], 'EXT_display_color_table')
GLuint = c_uint # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:26
# http://developer.download.nvidia.com/opengl/includes/wglext.h:440
wglLoadDisplayColorTableEXT = _link_function('wglLoadDisplayColorTableEXT', GLboolean, [POINTER(GLushort), GLuint], 'EXT_display_color_table')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:441
wglBindDisplayColorTableEXT = _link_function('wglBindDisplayColorTableEXT', GLboolean, [GLushort], 'EXT_display_color_table')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:442
wglDestroyDisplayColorTableEXT = _link_function('wglDestroyDisplayColorTableEXT', VOID, [GLushort], 'EXT_display_color_table')
PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, GLushort) # http://developer.download.nvidia.com/opengl/includes/wglext.h:444
PFNWGLLOADDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, POINTER(GLushort), GLuint) # http://developer.download.nvidia.com/opengl/includes/wglext.h:445
PFNWGLBINDDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, GLushort) # http://developer.download.nvidia.com/opengl/includes/wglext.h:446
PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(VOID, GLushort) # http://developer.download.nvidia.com/opengl/includes/wglext.h:447
# EXT_extensions_string (http://developer.download.nvidia.com/opengl/includes/wglext.h:450)
WGL_EXT_extensions_string = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:451
# http://developer.download.nvidia.com/opengl/includes/wglext.h:453
wglGetExtensionsStringEXT = _link_function('wglGetExtensionsStringEXT', c_char_p, [], 'EXT_extensions_string')
PFNWGLGETEXTENSIONSSTRINGEXTPROC = CFUNCTYPE(c_char_p) # http://developer.download.nvidia.com/opengl/includes/wglext.h:455
# EXT_make_current_read (http://developer.download.nvidia.com/opengl/includes/wglext.h:458)
WGL_EXT_make_current_read = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:459
# http://developer.download.nvidia.com/opengl/includes/wglext.h:461
wglMakeContextCurrentEXT = _link_function('wglMakeContextCurrentEXT', BOOL, [HDC, HDC, HGLRC], 'EXT_make_current_read')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:462
wglGetCurrentReadDCEXT = _link_function('wglGetCurrentReadDCEXT', HDC, [], 'EXT_make_current_read')
PFNWGLMAKECONTEXTCURRENTEXTPROC = CFUNCTYPE(BOOL, HDC, HDC, HGLRC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:464
PFNWGLGETCURRENTREADDCEXTPROC = CFUNCTYPE(HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:465
# EXT_pbuffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:468)
WGL_EXT_pbuffer = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:469
# http://developer.download.nvidia.com/opengl/includes/wglext.h:471
wglCreatePbufferEXT = _link_function('wglCreatePbufferEXT', HPBUFFEREXT, [HDC, c_int, c_int, c_int, POINTER(c_int)], 'EXT_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:472
wglGetPbufferDCEXT = _link_function('wglGetPbufferDCEXT', HDC, [HPBUFFEREXT], 'EXT_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:473
wglReleasePbufferDCEXT = _link_function('wglReleasePbufferDCEXT', c_int, [HPBUFFEREXT, HDC], 'EXT_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:474
wglDestroyPbufferEXT = _link_function('wglDestroyPbufferEXT', BOOL, [HPBUFFEREXT], 'EXT_pbuffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:475
wglQueryPbufferEXT = _link_function('wglQueryPbufferEXT', BOOL, [HPBUFFEREXT, c_int, POINTER(c_int)], 'EXT_pbuffer')
PFNWGLCREATEPBUFFEREXTPROC = CFUNCTYPE(HPBUFFEREXT, HDC, c_int, c_int, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:477
PFNWGLGETPBUFFERDCEXTPROC = CFUNCTYPE(HDC, HPBUFFEREXT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:478
PFNWGLRELEASEPBUFFERDCEXTPROC = CFUNCTYPE(c_int, HPBUFFEREXT, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:479
PFNWGLDESTROYPBUFFEREXTPROC = CFUNCTYPE(BOOL, HPBUFFEREXT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:480
PFNWGLQUERYPBUFFEREXTPROC = CFUNCTYPE(BOOL, HPBUFFEREXT, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:481
# EXT_pixel_format (http://developer.download.nvidia.com/opengl/includes/wglext.h:484)
WGL_EXT_pixel_format = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:485
# http://developer.download.nvidia.com/opengl/includes/wglext.h:487
wglGetPixelFormatAttribivEXT = _link_function('wglGetPixelFormatAttribivEXT', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)], 'EXT_pixel_format')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:488
wglGetPixelFormatAttribfvEXT = _link_function('wglGetPixelFormatAttribfvEXT', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)], 'EXT_pixel_format')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:489
wglChoosePixelFormatEXT = _link_function('wglChoosePixelFormatEXT', BOOL, [HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)], 'EXT_pixel_format')
PFNWGLGETPIXELFORMATATTRIBIVEXTPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:491
PFNWGLGETPIXELFORMATATTRIBFVEXTPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:492
PFNWGLCHOOSEPIXELFORMATEXTPROC = CFUNCTYPE(BOOL, HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:493
# EXT_swap_control (http://developer.download.nvidia.com/opengl/includes/wglext.h:496)
WGL_EXT_swap_control = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:497
# http://developer.download.nvidia.com/opengl/includes/wglext.h:499
wglSwapIntervalEXT = _link_function('wglSwapIntervalEXT', BOOL, [c_int], 'EXT_swap_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:500
wglGetSwapIntervalEXT = _link_function('wglGetSwapIntervalEXT', c_int, [], 'EXT_swap_control')
PFNWGLSWAPINTERVALEXTPROC = CFUNCTYPE(BOOL, c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:502
PFNWGLGETSWAPINTERVALEXTPROC = CFUNCTYPE(c_int) # http://developer.download.nvidia.com/opengl/includes/wglext.h:503
# EXT_depth_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:506)
WGL_EXT_depth_float = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:507
# NV_vertex_array_range (http://developer.download.nvidia.com/opengl/includes/wglext.h:510)
WGL_NV_vertex_array_range = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:511
GLsizei = c_int # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:23
GLfloat = c_float # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:27
# http://developer.download.nvidia.com/opengl/includes/wglext.h:513
wglAllocateMemoryNV = _link_function('wglAllocateMemoryNV', POINTER(c_void), [GLsizei, GLfloat, GLfloat, GLfloat], 'NV_vertex_array_range')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:514
wglFreeMemoryNV = _link_function('wglFreeMemoryNV', None, [POINTER(None)], 'NV_vertex_array_range')
PFNWGLALLOCATEMEMORYNVPROC = CFUNCTYPE(POINTER(c_void), GLsizei, GLfloat, GLfloat, GLfloat) # http://developer.download.nvidia.com/opengl/includes/wglext.h:516
PFNWGLFREEMEMORYNVPROC = CFUNCTYPE(None, POINTER(None)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:517
# 3DFX_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:520)
WGL_3DFX_multisample = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:521
# EXT_multisample (http://developer.download.nvidia.com/opengl/includes/wglext.h:524)
WGL_EXT_multisample = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:525
# OML_sync_control (http://developer.download.nvidia.com/opengl/includes/wglext.h:528)
WGL_OML_sync_control = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:529
INT64 = c_longlong # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:42
# http://developer.download.nvidia.com/opengl/includes/wglext.h:531
wglGetSyncValuesOML = _link_function('wglGetSyncValuesOML', BOOL, [HDC, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
INT32 = c_int # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:35
# http://developer.download.nvidia.com/opengl/includes/wglext.h:532
wglGetMscRateOML = _link_function('wglGetMscRateOML', BOOL, [HDC, POINTER(INT32), POINTER(INT32)], 'OML_sync_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:533
wglSwapBuffersMscOML = _link_function('wglSwapBuffersMscOML', INT64, [HDC, INT64, INT64, INT64], 'OML_sync_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:534
wglSwapLayerBuffersMscOML = _link_function('wglSwapLayerBuffersMscOML', INT64, [HDC, c_int, INT64, INT64, INT64], 'OML_sync_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:535
wglWaitForMscOML = _link_function('wglWaitForMscOML', BOOL, [HDC, INT64, INT64, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:536
wglWaitForSbcOML = _link_function('wglWaitForSbcOML', BOOL, [HDC, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
PFNWGLGETSYNCVALUESOMLPROC = CFUNCTYPE(BOOL, HDC, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:538
PFNWGLGETMSCRATEOMLPROC = CFUNCTYPE(BOOL, HDC, POINTER(INT32), POINTER(INT32)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:539
PFNWGLSWAPBUFFERSMSCOMLPROC = CFUNCTYPE(INT64, HDC, INT64, INT64, INT64) # http://developer.download.nvidia.com/opengl/includes/wglext.h:540
PFNWGLSWAPLAYERBUFFERSMSCOMLPROC = CFUNCTYPE(INT64, HDC, c_int, INT64, INT64, INT64) # http://developer.download.nvidia.com/opengl/includes/wglext.h:541
PFNWGLWAITFORMSCOMLPROC = CFUNCTYPE(BOOL, HDC, INT64, INT64, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:542
PFNWGLWAITFORSBCOMLPROC = CFUNCTYPE(BOOL, HDC, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:543
# I3D_digital_video_control (http://developer.download.nvidia.com/opengl/includes/wglext.h:546)
WGL_I3D_digital_video_control = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:547
# http://developer.download.nvidia.com/opengl/includes/wglext.h:549
wglGetDigitalVideoParametersI3D = _link_function('wglGetDigitalVideoParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_digital_video_control')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:550
wglSetDigitalVideoParametersI3D = _link_function('wglSetDigitalVideoParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_digital_video_control')
PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:552
PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:553
# I3D_gamma (http://developer.download.nvidia.com/opengl/includes/wglext.h:556)
WGL_I3D_gamma = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:557
# http://developer.download.nvidia.com/opengl/includes/wglext.h:559
wglGetGammaTableParametersI3D = _link_function('wglGetGammaTableParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_gamma')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:560
wglSetGammaTableParametersI3D = _link_function('wglSetGammaTableParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_gamma')
USHORT = c_ushort # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:49
# http://developer.download.nvidia.com/opengl/includes/wglext.h:561
wglGetGammaTableI3D = _link_function('wglGetGammaTableI3D', BOOL, [HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)], 'I3D_gamma')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:562
wglSetGammaTableI3D = _link_function('wglSetGammaTableI3D', BOOL, [HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)], 'I3D_gamma')
PFNWGLGETGAMMATABLEPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:564
PFNWGLSETGAMMATABLEPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:565
PFNWGLGETGAMMATABLEI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:566
PFNWGLSETGAMMATABLEI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:567
# I3D_genlock (http://developer.download.nvidia.com/opengl/includes/wglext.h:570)
WGL_I3D_genlock = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:571
# http://developer.download.nvidia.com/opengl/includes/wglext.h:573
wglEnableGenlockI3D = _link_function('wglEnableGenlockI3D', BOOL, [HDC], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:574
wglDisableGenlockI3D = _link_function('wglDisableGenlockI3D', BOOL, [HDC], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:575
wglIsEnabledGenlockI3D = _link_function('wglIsEnabledGenlockI3D', BOOL, [HDC, POINTER(BOOL)], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:576
wglGenlockSourceI3D = _link_function('wglGenlockSourceI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:577
wglGetGenlockSourceI3D = _link_function('wglGetGenlockSourceI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:578
wglGenlockSourceEdgeI3D = _link_function('wglGenlockSourceEdgeI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:579
wglGetGenlockSourceEdgeI3D = _link_function('wglGetGenlockSourceEdgeI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:580
wglGenlockSampleRateI3D = _link_function('wglGenlockSampleRateI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:581
wglGetGenlockSampleRateI3D = _link_function('wglGetGenlockSampleRateI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:582
wglGenlockSourceDelayI3D = _link_function('wglGenlockSourceDelayI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:583
wglGetGenlockSourceDelayI3D = _link_function('wglGetGenlockSourceDelayI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:584
wglQueryGenlockMaxSourceDelayI3D = _link_function('wglQueryGenlockMaxSourceDelayI3D', BOOL, [HDC, POINTER(UINT), POINTER(UINT)], 'I3D_genlock')
PFNWGLENABLEGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:586
PFNWGLDISABLEGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:587
PFNWGLISENABLEDGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(BOOL)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:588
PFNWGLGENLOCKSOURCEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:589
PFNWGLGETGENLOCKSOURCEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:590
PFNWGLGENLOCKSOURCEEDGEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:591
PFNWGLGETGENLOCKSOURCEEDGEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:592
PFNWGLGENLOCKSAMPLERATEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:593
PFNWGLGETGENLOCKSAMPLERATEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:594
PFNWGLGENLOCKSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:595
PFNWGLGETGENLOCKSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:596
PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT), POINTER(UINT)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:597
# I3D_image_buffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:600)
WGL_I3D_image_buffer = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:601
LPVOID = POINTER(None) # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:45
# http://developer.download.nvidia.com/opengl/includes/wglext.h:603
wglCreateImageBufferI3D = _link_function('wglCreateImageBufferI3D', LPVOID, [HDC, DWORD, UINT], 'I3D_image_buffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:604
wglDestroyImageBufferI3D = _link_function('wglDestroyImageBufferI3D', BOOL, [HDC, LPVOID], 'I3D_image_buffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:605
wglAssociateImageBufferEventsI3D = _link_function('wglAssociateImageBufferEventsI3D', BOOL, [HDC, POINTER(HANDLE), POINTER(LPVOID), POINTER(DWORD), UINT], 'I3D_image_buffer')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:606
wglReleaseImageBufferEventsI3D = _link_function('wglReleaseImageBufferEventsI3D', BOOL, [HDC, POINTER(LPVOID), UINT], 'I3D_image_buffer')
PFNWGLCREATEIMAGEBUFFERI3DPROC = CFUNCTYPE(LPVOID, HDC, DWORD, UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:608
PFNWGLDESTROYIMAGEBUFFERI3DPROC = CFUNCTYPE(BOOL, HDC, LPVOID) # http://developer.download.nvidia.com/opengl/includes/wglext.h:609
PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(HANDLE), POINTER(LPVOID), POINTER(DWORD), UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:610
PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(LPVOID), UINT) # http://developer.download.nvidia.com/opengl/includes/wglext.h:611
# I3D_swap_frame_lock (http://developer.download.nvidia.com/opengl/includes/wglext.h:614)
WGL_I3D_swap_frame_lock = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:615
# http://developer.download.nvidia.com/opengl/includes/wglext.h:617
wglEnableFrameLockI3D = _link_function('wglEnableFrameLockI3D', BOOL, [], 'I3D_swap_frame_lock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:618
wglDisableFrameLockI3D = _link_function('wglDisableFrameLockI3D', BOOL, [], 'I3D_swap_frame_lock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:619
wglIsEnabledFrameLockI3D = _link_function('wglIsEnabledFrameLockI3D', BOOL, [POINTER(BOOL)], 'I3D_swap_frame_lock')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:620
wglQueryFrameLockMasterI3D = _link_function('wglQueryFrameLockMasterI3D', BOOL, [POINTER(BOOL)], 'I3D_swap_frame_lock')
PFNWGLENABLEFRAMELOCKI3DPROC = CFUNCTYPE(BOOL) # http://developer.download.nvidia.com/opengl/includes/wglext.h:622
PFNWGLDISABLEFRAMELOCKI3DPROC = CFUNCTYPE(BOOL) # http://developer.download.nvidia.com/opengl/includes/wglext.h:623
PFNWGLISENABLEDFRAMELOCKI3DPROC = CFUNCTYPE(BOOL, POINTER(BOOL)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:624
PFNWGLQUERYFRAMELOCKMASTERI3DPROC = CFUNCTYPE(BOOL, POINTER(BOOL)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:625
# I3D_swap_frame_usage (http://developer.download.nvidia.com/opengl/includes/wglext.h:628)
WGL_I3D_swap_frame_usage = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:629
# http://developer.download.nvidia.com/opengl/includes/wglext.h:631
wglGetFrameUsageI3D = _link_function('wglGetFrameUsageI3D', BOOL, [POINTER(c_float)], 'I3D_swap_frame_usage')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:632
wglBeginFrameTrackingI3D = _link_function('wglBeginFrameTrackingI3D', BOOL, [], 'I3D_swap_frame_usage')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:633
wglEndFrameTrackingI3D = _link_function('wglEndFrameTrackingI3D', BOOL, [], 'I3D_swap_frame_usage')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:634
wglQueryFrameTrackingI3D = _link_function('wglQueryFrameTrackingI3D', BOOL, [POINTER(DWORD), POINTER(DWORD), POINTER(c_float)], 'I3D_swap_frame_usage')
PFNWGLGETFRAMEUSAGEI3DPROC = CFUNCTYPE(BOOL, POINTER(c_float)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:636
PFNWGLBEGINFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL) # http://developer.download.nvidia.com/opengl/includes/wglext.h:637
PFNWGLENDFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL) # http://developer.download.nvidia.com/opengl/includes/wglext.h:638
PFNWGLQUERYFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL, POINTER(DWORD), POINTER(DWORD), POINTER(c_float)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:639
# ATI_pixel_format_float (http://developer.download.nvidia.com/opengl/includes/wglext.h:642)
WGL_ATI_pixel_format_float = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:643
# NV_render_depth_texture (http://developer.download.nvidia.com/opengl/includes/wglext.h:646)
WGL_NV_render_depth_texture = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:647
# NV_render_texture_rectangle (http://developer.download.nvidia.com/opengl/includes/wglext.h:650)
WGL_NV_render_texture_rectangle = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:651
# NV_float_buffer (http://developer.download.nvidia.com/opengl/includes/wglext.h:654)
WGL_NV_float_buffer = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:655
# NV_swap_group (http://developer.download.nvidia.com/opengl/includes/wglext.h:658)
WGL_NV_swap_group = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:659
# http://developer.download.nvidia.com/opengl/includes/wglext.h:661
wglJoinSwapGroupNV = _link_function('wglJoinSwapGroupNV', BOOL, [HDC, GLuint], 'NV_swap_group')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:662
wglBindSwapBarrierNV = _link_function('wglBindSwapBarrierNV', BOOL, [GLuint, GLuint], 'NV_swap_group')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:663
wglQuerySwapGroupNV = _link_function('wglQuerySwapGroupNV', BOOL, [HDC, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:664
wglQueryMaxSwapGroupsNV = _link_function('wglQueryMaxSwapGroupsNV', BOOL, [HDC, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:665
wglQueryFrameCountNV = _link_function('wglQueryFrameCountNV', BOOL, [HDC, POINTER(GLuint)], 'NV_swap_group')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:666
wglResetFrameCountNV = _link_function('wglResetFrameCountNV', BOOL, [HDC], 'NV_swap_group')
PFNWGLJOINSWAPGROUPNVPROC = CFUNCTYPE(BOOL, HDC, GLuint) # http://developer.download.nvidia.com/opengl/includes/wglext.h:668
PFNWGLBINDSWAPBARRIERNVPROC = CFUNCTYPE(BOOL, GLuint, GLuint) # http://developer.download.nvidia.com/opengl/includes/wglext.h:669
PFNWGLQUERYSWAPGROUPNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint), POINTER(GLuint)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:670
PFNWGLQUERYMAXSWAPGROUPSNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint), POINTER(GLuint)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:671
PFNWGLQUERYFRAMECOUNTNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint)) # http://developer.download.nvidia.com/opengl/includes/wglext.h:672
PFNWGLRESETFRAMECOUNTNVPROC = CFUNCTYPE(BOOL, HDC) # http://developer.download.nvidia.com/opengl/includes/wglext.h:673
# NV_gpu_affinity (http://developer.download.nvidia.com/opengl/includes/wglext.h:676)
WGL_NV_gpu_affinity = 1 # http://developer.download.nvidia.com/opengl/includes/wglext.h:677
# http://developer.download.nvidia.com/opengl/includes/wglext.h:679
wglEnumGpusNV = _link_function('wglEnumGpusNV', BOOL, [UINT, POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:680
wglEnumGpuDevicesNV = _link_function('wglEnumGpuDevicesNV', BOOL, [HGPUNV, UINT, PGPU_DEVICE], 'NV_gpu_affinity')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:681
wglCreateAffinityDCNV = _link_function('wglCreateAffinityDCNV', HDC, [POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:682
wglEnumGpusFromAffinityDCNV = _link_function('wglEnumGpusFromAffinityDCNV', BOOL, [HDC, UINT, POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://developer.download.nvidia.com/opengl/includes/wglext.h:683
wglDeleteDCNV = _link_function('wglDeleteDCNV', BOOL, [HDC], 'NV_gpu_affinity')
__all__ = ['WIN32_LEAN_AND_MEAN', 'WGL_WGLEXT_VERSION',
'WGL_FRONT_COLOR_BUFFER_BIT_ARB', 'WGL_BACK_COLOR_BUFFER_BIT_ARB',
'WGL_DEPTH_BUFFER_BIT_ARB', 'WGL_STENCIL_BUFFER_BIT_ARB',
'WGL_SAMPLE_BUFFERS_ARB', 'WGL_SAMPLES_ARB', 'WGL_NUMBER_PIXEL_FORMATS_ARB',
'WGL_DRAW_TO_WINDOW_ARB', 'WGL_DRAW_TO_BITMAP_ARB', 'WGL_ACCELERATION_ARB',
'WGL_NEED_PALETTE_ARB', 'WGL_NEED_SYSTEM_PALETTE_ARB',
'WGL_SWAP_LAYER_BUFFERS_ARB', 'WGL_SWAP_METHOD_ARB',
'WGL_NUMBER_OVERLAYS_ARB', 'WGL_NUMBER_UNDERLAYS_ARB', 'WGL_TRANSPARENT_ARB',
'WGL_TRANSPARENT_RED_VALUE_ARB', 'WGL_TRANSPARENT_GREEN_VALUE_ARB',
'WGL_TRANSPARENT_BLUE_VALUE_ARB', 'WGL_TRANSPARENT_ALPHA_VALUE_ARB',
'WGL_TRANSPARENT_INDEX_VALUE_ARB', 'WGL_SHARE_DEPTH_ARB',
'WGL_SHARE_STENCIL_ARB', 'WGL_SHARE_ACCUM_ARB', 'WGL_SUPPORT_GDI_ARB',
'WGL_SUPPORT_OPENGL_ARB', 'WGL_DOUBLE_BUFFER_ARB', 'WGL_STEREO_ARB',
'WGL_PIXEL_TYPE_ARB', 'WGL_COLOR_BITS_ARB', 'WGL_RED_BITS_ARB',
'WGL_RED_SHIFT_ARB', 'WGL_GREEN_BITS_ARB', 'WGL_GREEN_SHIFT_ARB',
'WGL_BLUE_BITS_ARB', 'WGL_BLUE_SHIFT_ARB', 'WGL_ALPHA_BITS_ARB',
'WGL_ALPHA_SHIFT_ARB', 'WGL_ACCUM_BITS_ARB', 'WGL_ACCUM_RED_BITS_ARB',
'WGL_ACCUM_GREEN_BITS_ARB', 'WGL_ACCUM_BLUE_BITS_ARB',
'WGL_ACCUM_ALPHA_BITS_ARB', 'WGL_DEPTH_BITS_ARB', 'WGL_STENCIL_BITS_ARB',
'WGL_AUX_BUFFERS_ARB', 'WGL_NO_ACCELERATION_ARB',
'WGL_GENERIC_ACCELERATION_ARB', 'WGL_FULL_ACCELERATION_ARB',
'WGL_SWAP_EXCHANGE_ARB', 'WGL_SWAP_COPY_ARB', 'WGL_SWAP_UNDEFINED_ARB',
'WGL_TYPE_RGBA_ARB', 'WGL_TYPE_COLORINDEX_ARB',
'ERROR_INVALID_PIXEL_TYPE_ARB', 'ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB',
'WGL_DRAW_TO_PBUFFER_ARB', 'WGL_MAX_PBUFFER_PIXELS_ARB',
'WGL_MAX_PBUFFER_WIDTH_ARB', 'WGL_MAX_PBUFFER_HEIGHT_ARB',
'WGL_PBUFFER_LARGEST_ARB', 'WGL_PBUFFER_WIDTH_ARB', 'WGL_PBUFFER_HEIGHT_ARB',
'WGL_PBUFFER_LOST_ARB', 'WGL_BIND_TO_TEXTURE_RGB_ARB',
'WGL_BIND_TO_TEXTURE_RGBA_ARB', 'WGL_TEXTURE_FORMAT_ARB',
'WGL_TEXTURE_TARGET_ARB', 'WGL_MIPMAP_TEXTURE_ARB', 'WGL_TEXTURE_RGB_ARB',
'WGL_TEXTURE_RGBA_ARB', 'WGL_NO_TEXTURE_ARB', 'WGL_TEXTURE_CUBE_MAP_ARB',
'WGL_TEXTURE_1D_ARB', 'WGL_TEXTURE_2D_ARB', 'WGL_MIPMAP_LEVEL_ARB',
'WGL_CUBE_MAP_FACE_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB', 'WGL_FRONT_LEFT_ARB',
'WGL_FRONT_RIGHT_ARB', 'WGL_BACK_LEFT_ARB', 'WGL_BACK_RIGHT_ARB',
'WGL_AUX0_ARB', 'WGL_AUX1_ARB', 'WGL_AUX2_ARB', 'WGL_AUX3_ARB',
'WGL_AUX4_ARB', 'WGL_AUX5_ARB', 'WGL_AUX6_ARB', 'WGL_AUX7_ARB',
'WGL_AUX8_ARB', 'WGL_AUX9_ARB', 'WGL_TYPE_RGBA_FLOAT_ARB',
'ERROR_INVALID_PIXEL_TYPE_EXT', 'WGL_NUMBER_PIXEL_FORMATS_EXT',
'WGL_DRAW_TO_WINDOW_EXT', 'WGL_DRAW_TO_BITMAP_EXT', 'WGL_ACCELERATION_EXT',
'WGL_NEED_PALETTE_EXT', 'WGL_NEED_SYSTEM_PALETTE_EXT',
'WGL_SWAP_LAYER_BUFFERS_EXT', 'WGL_SWAP_METHOD_EXT',
'WGL_NUMBER_OVERLAYS_EXT', 'WGL_NUMBER_UNDERLAYS_EXT', 'WGL_TRANSPARENT_EXT',
'WGL_TRANSPARENT_VALUE_EXT', 'WGL_SHARE_DEPTH_EXT', 'WGL_SHARE_STENCIL_EXT',
'WGL_SHARE_ACCUM_EXT', 'WGL_SUPPORT_GDI_EXT', 'WGL_SUPPORT_OPENGL_EXT',
'WGL_DOUBLE_BUFFER_EXT', 'WGL_STEREO_EXT', 'WGL_PIXEL_TYPE_EXT',
'WGL_COLOR_BITS_EXT', 'WGL_RED_BITS_EXT', 'WGL_RED_SHIFT_EXT',
'WGL_GREEN_BITS_EXT', 'WGL_GREEN_SHIFT_EXT', 'WGL_BLUE_BITS_EXT',
'WGL_BLUE_SHIFT_EXT', 'WGL_ALPHA_BITS_EXT', 'WGL_ALPHA_SHIFT_EXT',
'WGL_ACCUM_BITS_EXT', 'WGL_ACCUM_RED_BITS_EXT', 'WGL_ACCUM_GREEN_BITS_EXT',
'WGL_ACCUM_BLUE_BITS_EXT', 'WGL_ACCUM_ALPHA_BITS_EXT', 'WGL_DEPTH_BITS_EXT',
'WGL_STENCIL_BITS_EXT', 'WGL_AUX_BUFFERS_EXT', 'WGL_NO_ACCELERATION_EXT',
'WGL_GENERIC_ACCELERATION_EXT', 'WGL_FULL_ACCELERATION_EXT',
'WGL_SWAP_EXCHANGE_EXT', 'WGL_SWAP_COPY_EXT', 'WGL_SWAP_UNDEFINED_EXT',
'WGL_TYPE_RGBA_EXT', 'WGL_TYPE_COLORINDEX_EXT', 'WGL_DRAW_TO_PBUFFER_EXT',
'WGL_MAX_PBUFFER_PIXELS_EXT', 'WGL_MAX_PBUFFER_WIDTH_EXT',
'WGL_MAX_PBUFFER_HEIGHT_EXT', 'WGL_OPTIMAL_PBUFFER_WIDTH_EXT',
'WGL_OPTIMAL_PBUFFER_HEIGHT_EXT', 'WGL_PBUFFER_LARGEST_EXT',
'WGL_PBUFFER_WIDTH_EXT', 'WGL_PBUFFER_HEIGHT_EXT', 'WGL_DEPTH_FLOAT_EXT',
'WGL_SAMPLE_BUFFERS_3DFX', 'WGL_SAMPLES_3DFX', 'WGL_SAMPLE_BUFFERS_EXT',
'WGL_SAMPLES_EXT', 'WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D',
'WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D',
'WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D',
'WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D', 'WGL_GAMMA_TABLE_SIZE_I3D',
'WGL_GAMMA_EXCLUDE_DESKTOP_I3D', 'WGL_GENLOCK_SOURCE_MULTIVIEW_I3D',
'WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D', 'WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D',
'WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D', 'WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D',
'WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D', 'WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D',
'WGL_GENLOCK_SOURCE_EDGE_RISING_I3D', 'WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D',
'WGL_IMAGE_BUFFER_MIN_ACCESS_I3D', 'WGL_IMAGE_BUFFER_LOCK_I3D',
'WGL_BIND_TO_TEXTURE_DEPTH_NV', 'WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV',
'WGL_DEPTH_TEXTURE_FORMAT_NV', 'WGL_TEXTURE_DEPTH_COMPONENT_NV',
'WGL_DEPTH_COMPONENT_NV', 'WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV', 'WGL_TEXTURE_RECTANGLE_NV',
'WGL_TYPE_RGBA_FLOAT_ATI', 'WGL_RGBA_FLOAT_MODE_ATI',
'WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI', 'WGL_FLOAT_COMPONENTS_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV', 'WGL_TEXTURE_FLOAT_R_NV',
'WGL_TEXTURE_FLOAT_RG_NV', 'WGL_TEXTURE_FLOAT_RGB_NV',
'WGL_TEXTURE_FLOAT_RGBA_NV', 'WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV',
'WGL_ERROR_MISSING_AFFINITY_MASK_NV', 'HPBUFFERARB', 'HPBUFFEREXT', 'HGPUNV',
'GPU_DEVICE', 'PGPU_DEVICE', 'WGL_ARB_buffer_region',
'wglCreateBufferRegionARB', 'wglDeleteBufferRegionARB',
'wglSaveBufferRegionARB', 'wglRestoreBufferRegionARB',
'PFNWGLCREATEBUFFERREGIONARBPROC', 'PFNWGLDELETEBUFFERREGIONARBPROC',
'PFNWGLSAVEBUFFERREGIONARBPROC', 'PFNWGLRESTOREBUFFERREGIONARBPROC',
'WGL_ARB_multisample', 'WGL_ARB_extensions_string',
'wglGetExtensionsStringARB', 'PFNWGLGETEXTENSIONSSTRINGARBPROC',
'WGL_ARB_pixel_format', 'wglGetPixelFormatAttribivARB',
'wglGetPixelFormatAttribfvARB', 'wglChoosePixelFormatARB',
'PFNWGLGETPIXELFORMATATTRIBIVARBPROC', 'PFNWGLGETPIXELFORMATATTRIBFVARBPROC',
'PFNWGLCHOOSEPIXELFORMATARBPROC', 'WGL_ARB_make_current_read',
'wglMakeContextCurrentARB', 'wglGetCurrentReadDCARB',
'PFNWGLMAKECONTEXTCURRENTARBPROC', 'PFNWGLGETCURRENTREADDCARBPROC',
'WGL_ARB_pbuffer', 'wglCreatePbufferARB', 'wglGetPbufferDCARB',
'wglReleasePbufferDCARB', 'wglDestroyPbufferARB', 'wglQueryPbufferARB',
'PFNWGLCREATEPBUFFERARBPROC', 'PFNWGLGETPBUFFERDCARBPROC',
'PFNWGLRELEASEPBUFFERDCARBPROC', 'PFNWGLDESTROYPBUFFERARBPROC',
'PFNWGLQUERYPBUFFERARBPROC', 'WGL_ARB_render_texture', 'wglBindTexImageARB',
'wglReleaseTexImageARB', 'wglSetPbufferAttribARB',
'PFNWGLBINDTEXIMAGEARBPROC', 'PFNWGLRELEASETEXIMAGEARBPROC',
'PFNWGLSETPBUFFERATTRIBARBPROC', 'WGL_ARB_pixel_format_float',
'WGL_EXT_display_color_table', 'wglCreateDisplayColorTableEXT',
'wglLoadDisplayColorTableEXT', 'wglBindDisplayColorTableEXT',
'wglDestroyDisplayColorTableEXT', 'PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC',
'PFNWGLLOADDISPLAYCOLORTABLEEXTPROC', 'PFNWGLBINDDISPLAYCOLORTABLEEXTPROC',
'PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC', 'WGL_EXT_extensions_string',
'wglGetExtensionsStringEXT', 'PFNWGLGETEXTENSIONSSTRINGEXTPROC',
'WGL_EXT_make_current_read', 'wglMakeContextCurrentEXT',
'wglGetCurrentReadDCEXT', 'PFNWGLMAKECONTEXTCURRENTEXTPROC',
'PFNWGLGETCURRENTREADDCEXTPROC', 'WGL_EXT_pbuffer', 'wglCreatePbufferEXT',
'wglGetPbufferDCEXT', 'wglReleasePbufferDCEXT', 'wglDestroyPbufferEXT',
'wglQueryPbufferEXT', 'PFNWGLCREATEPBUFFEREXTPROC',
'PFNWGLGETPBUFFERDCEXTPROC', 'PFNWGLRELEASEPBUFFERDCEXTPROC',
'PFNWGLDESTROYPBUFFEREXTPROC', 'PFNWGLQUERYPBUFFEREXTPROC',
'WGL_EXT_pixel_format', 'wglGetPixelFormatAttribivEXT',
'wglGetPixelFormatAttribfvEXT', 'wglChoosePixelFormatEXT',
'PFNWGLGETPIXELFORMATATTRIBIVEXTPROC', 'PFNWGLGETPIXELFORMATATTRIBFVEXTPROC',
'PFNWGLCHOOSEPIXELFORMATEXTPROC', 'WGL_EXT_swap_control',
'wglSwapIntervalEXT', 'wglGetSwapIntervalEXT', 'PFNWGLSWAPINTERVALEXTPROC',
'PFNWGLGETSWAPINTERVALEXTPROC', 'WGL_EXT_depth_float',
'WGL_NV_vertex_array_range', 'wglAllocateMemoryNV', 'wglFreeMemoryNV',
'PFNWGLALLOCATEMEMORYNVPROC', 'PFNWGLFREEMEMORYNVPROC',
'WGL_3DFX_multisample', 'WGL_EXT_multisample', 'WGL_OML_sync_control',
'wglGetSyncValuesOML', 'wglGetMscRateOML', 'wglSwapBuffersMscOML',
'wglSwapLayerBuffersMscOML', 'wglWaitForMscOML', 'wglWaitForSbcOML',
'PFNWGLGETSYNCVALUESOMLPROC', 'PFNWGLGETMSCRATEOMLPROC',
'PFNWGLSWAPBUFFERSMSCOMLPROC', 'PFNWGLSWAPLAYERBUFFERSMSCOMLPROC',
'PFNWGLWAITFORMSCOMLPROC', 'PFNWGLWAITFORSBCOMLPROC',
'WGL_I3D_digital_video_control', 'wglGetDigitalVideoParametersI3D',
'wglSetDigitalVideoParametersI3D', 'PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC',
'PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC', 'WGL_I3D_gamma',
'wglGetGammaTableParametersI3D', 'wglSetGammaTableParametersI3D',
'wglGetGammaTableI3D', 'wglSetGammaTableI3D',
'PFNWGLGETGAMMATABLEPARAMETERSI3DPROC',
'PFNWGLSETGAMMATABLEPARAMETERSI3DPROC', 'PFNWGLGETGAMMATABLEI3DPROC',
'PFNWGLSETGAMMATABLEI3DPROC', 'WGL_I3D_genlock', 'wglEnableGenlockI3D',
'wglDisableGenlockI3D', 'wglIsEnabledGenlockI3D', 'wglGenlockSourceI3D',
'wglGetGenlockSourceI3D', 'wglGenlockSourceEdgeI3D',
'wglGetGenlockSourceEdgeI3D', 'wglGenlockSampleRateI3D',
'wglGetGenlockSampleRateI3D', 'wglGenlockSourceDelayI3D',
'wglGetGenlockSourceDelayI3D', 'wglQueryGenlockMaxSourceDelayI3D',
'PFNWGLENABLEGENLOCKI3DPROC', 'PFNWGLDISABLEGENLOCKI3DPROC',
'PFNWGLISENABLEDGENLOCKI3DPROC', 'PFNWGLGENLOCKSOURCEI3DPROC',
'PFNWGLGETGENLOCKSOURCEI3DPROC', 'PFNWGLGENLOCKSOURCEEDGEI3DPROC',
'PFNWGLGETGENLOCKSOURCEEDGEI3DPROC', 'PFNWGLGENLOCKSAMPLERATEI3DPROC',
'PFNWGLGETGENLOCKSAMPLERATEI3DPROC', 'PFNWGLGENLOCKSOURCEDELAYI3DPROC',
'PFNWGLGETGENLOCKSOURCEDELAYI3DPROC',
'PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC', 'WGL_I3D_image_buffer',
'wglCreateImageBufferI3D', 'wglDestroyImageBufferI3D',
'wglAssociateImageBufferEventsI3D', 'wglReleaseImageBufferEventsI3D',
'PFNWGLCREATEIMAGEBUFFERI3DPROC', 'PFNWGLDESTROYIMAGEBUFFERI3DPROC',
'PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC',
'PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC', 'WGL_I3D_swap_frame_lock',
'wglEnableFrameLockI3D', 'wglDisableFrameLockI3D', 'wglIsEnabledFrameLockI3D',
'wglQueryFrameLockMasterI3D', 'PFNWGLENABLEFRAMELOCKI3DPROC',
'PFNWGLDISABLEFRAMELOCKI3DPROC', 'PFNWGLISENABLEDFRAMELOCKI3DPROC',
'PFNWGLQUERYFRAMELOCKMASTERI3DPROC', 'WGL_I3D_swap_frame_usage',
'wglGetFrameUsageI3D', 'wglBeginFrameTrackingI3D', 'wglEndFrameTrackingI3D',
'wglQueryFrameTrackingI3D', 'PFNWGLGETFRAMEUSAGEI3DPROC',
'PFNWGLBEGINFRAMETRACKINGI3DPROC', 'PFNWGLENDFRAMETRACKINGI3DPROC',
'PFNWGLQUERYFRAMETRACKINGI3DPROC', 'WGL_ATI_pixel_format_float',
'WGL_NV_render_depth_texture', 'WGL_NV_render_texture_rectangle',
'WGL_NV_float_buffer', 'WGL_NV_swap_group', 'wglJoinSwapGroupNV',
'wglBindSwapBarrierNV', 'wglQuerySwapGroupNV', 'wglQueryMaxSwapGroupsNV',
'wglQueryFrameCountNV', 'wglResetFrameCountNV', 'PFNWGLJOINSWAPGROUPNVPROC',
'PFNWGLBINDSWAPBARRIERNVPROC', 'PFNWGLQUERYSWAPGROUPNVPROC',
'PFNWGLQUERYMAXSWAPGROUPSNVPROC', 'PFNWGLQUERYFRAMECOUNTNVPROC',
'PFNWGLRESETFRAMECOUNTNVPROC', 'WGL_NV_gpu_affinity', 'wglEnumGpusNV',
'wglEnumGpuDevicesNV', 'wglCreateAffinityDCNV', 'wglEnumGpusFromAffinityDCNV',
'wglDeleteDCNV']
# END GENERATED CONTENT (do not edit above this line)
| Python |
#!/usr/bin/python
# $Id:$
from pyglet.canvas.win32 import Win32Canvas
from base import Config, CanvasConfig, Context
from pyglet import gl
from pyglet.gl import gl_info
from pyglet.gl import wgl
from pyglet.gl import wglext_arb
from pyglet.gl import wgl_info
from pyglet.libs.win32 import _user32, _kernel32, _gdi32
from pyglet.libs.win32.constants import *
from pyglet.libs.win32.types import *
class Win32Config(Config):
def match(self, canvas):
if not isinstance(canvas, Win32Canvas):
raise RuntimeError('Canvas must be instance of Win32Canvas')
# Use ARB API if available
if (gl_info.have_context() and
wgl_info.have_extension('WGL_ARB_pixel_format')):
return self._get_arb_pixel_format_matching_configs(canvas)
else:
return self._get_pixel_format_descriptor_matching_configs(canvas)
def _get_pixel_format_descriptor_matching_configs(self, canvas):
'''Get matching configs using standard PIXELFORMATDESCRIPTOR
technique.'''
pfd = PIXELFORMATDESCRIPTOR()
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR)
pfd.nVersion = 1
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL
if self.double_buffer:
pfd.dwFlags |= PFD_DOUBLEBUFFER
else:
pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE
if self.stereo:
pfd.dwFlags |= PFD_STEREO
else:
pfd.dwFlags |= PFD_STEREO_DONTCARE
'''Not supported in pyglet API
if attributes.get('swap_copy', False):
pfd.dwFlags |= PFD_SWAP_COPY
if attributes.get('swap_exchange', False):
pfd.dwFlags |= PFD_SWAP_EXCHANGE
'''
if not self.depth_size:
pfd.dwFlags |= PFD_DEPTH_DONTCARE
pfd.iPixelType = PFD_TYPE_RGBA
pfd.cColorBits = self.buffer_size or 0
pfd.cRedBits = self.red_size or 0
pfd.cGreenBits = self.green_size or 0
pfd.cBlueBits = self.blue_size or 0
pfd.cAlphaBits = self.alpha_size or 0
pfd.cAccumRedBits = self.accum_red_size or 0
pfd.cAccumGreenBits = self.accum_green_size or 0
pfd.cAccumBlueBits = self.accum_blue_size or 0
pfd.cAccumAlphaBits = self.accum_alpha_size or 0
pfd.cDepthBits = self.depth_size or 0
pfd.cStencilBits = self.stencil_size or 0
pfd.cAuxBuffers = self.aux_buffers or 0
pf = _gdi32.ChoosePixelFormat(canvas.hdc, byref(pfd))
if pf:
return [Win32CanvasConfig(canvas, pf, self)]
else:
return []
def _get_arb_pixel_format_matching_configs(self, canvas):
'''Get configs using the WGL_ARB_pixel_format extension.
This method assumes a (dummy) GL context is already created.'''
# Check for required extensions
if self.sample_buffers or self.samples:
if not gl_info.have_extension('GL_ARB_multisample'):
return []
# Construct array of attributes
attrs = []
for name, value in self.get_gl_attributes():
attr = Win32CanvasConfigARB.attribute_ids.get(name, None)
if attr and value is not None:
attrs.extend([attr, int(value)])
attrs.append(0)
attrs = (c_int * len(attrs))(*attrs)
pformats = (c_int * 16)()
nformats = c_uint(16)
wglext_arb.wglChoosePixelFormatARB(canvas.hdc, attrs, None,
nformats, pformats, nformats)
formats = [Win32CanvasConfigARB(canvas, pf, self) \
for pf in pformats[:nformats.value]]
return formats
class Win32CanvasConfig(CanvasConfig):
def __init__(self, canvas, pf, config):
super(Win32CanvasConfig, self).__init__(canvas, config)
self._pf = pf
self._pfd = PIXELFORMATDESCRIPTOR()
_gdi32.DescribePixelFormat(canvas.hdc,
self._pf, sizeof(PIXELFORMATDESCRIPTOR), byref(self._pfd))
self.double_buffer = bool(self._pfd.dwFlags & PFD_DOUBLEBUFFER)
self.sample_buffers = 0
self.samples = 0
self.stereo = bool(self._pfd.dwFlags & PFD_STEREO)
self.buffer_size = self._pfd.cColorBits
self.red_size = self._pfd.cRedBits
self.green_size = self._pfd.cGreenBits
self.blue_size = self._pfd.cBlueBits
self.alpha_size = self._pfd.cAlphaBits
self.accum_red_size = self._pfd.cAccumRedBits
self.accum_green_size = self._pfd.cAccumGreenBits
self.accum_blue_size = self._pfd.cAccumBlueBits
self.accum_alpha_size = self._pfd.cAccumAlphaBits
self.depth_size = self._pfd.cDepthBits
self.stencil_size = self._pfd.cStencilBits
self.aux_buffers = self._pfd.cAuxBuffers
def compatible(self, canvas):
# TODO more careful checking
return isinstance(canvas, Win32Canvas)
def create_context(self, share):
return Win32Context(self, share)
def _set_pixel_format(self, canvas):
_gdi32.SetPixelFormat(canvas.hdc, self._pf, byref(self._pfd))
class Win32CanvasConfigARB(CanvasConfig):
attribute_ids = {
'double_buffer': wglext_arb.WGL_DOUBLE_BUFFER_ARB,
'stereo': wglext_arb.WGL_STEREO_ARB,
'buffer_size': wglext_arb.WGL_COLOR_BITS_ARB,
'aux_buffers': wglext_arb.WGL_AUX_BUFFERS_ARB,
'sample_buffers': wglext_arb.WGL_SAMPLE_BUFFERS_ARB,
'samples': wglext_arb.WGL_SAMPLES_ARB,
'red_size': wglext_arb.WGL_RED_BITS_ARB,
'green_size': wglext_arb.WGL_GREEN_BITS_ARB,
'blue_size': wglext_arb.WGL_BLUE_BITS_ARB,
'alpha_size': wglext_arb.WGL_ALPHA_BITS_ARB,
'depth_size': wglext_arb.WGL_DEPTH_BITS_ARB,
'stencil_size': wglext_arb.WGL_STENCIL_BITS_ARB,
'accum_red_size': wglext_arb.WGL_ACCUM_RED_BITS_ARB,
'accum_green_size': wglext_arb.WGL_ACCUM_GREEN_BITS_ARB,
'accum_blue_size': wglext_arb.WGL_ACCUM_BLUE_BITS_ARB,
'accum_alpha_size': wglext_arb.WGL_ACCUM_ALPHA_BITS_ARB,
}
def __init__(self, canvas, pf, config):
super(Win32CanvasConfigARB, self).__init__(canvas, config)
self._pf = pf
names = self.attribute_ids.keys()
attrs = self.attribute_ids.values()
attrs = (c_int * len(attrs))(*attrs)
values = (c_int * len(attrs))()
result = wglext_arb.wglGetPixelFormatAttribivARB(canvas.hdc,
pf, 0, len(attrs), attrs, values)
for name, value in zip(names, values):
setattr(self, name, value)
def compatible(self, canvas):
# TODO more careful checking
return isinstance(canvas, Win32Canvas)
def create_context(self, share):
if wgl_info.have_extension('WGL_ARB_create_context'):
return Win32ARBContext(self, share)
else:
return Win32Context(self, share)
def _set_pixel_format(self, canvas):
_gdi32.SetPixelFormat(canvas.hdc, self._pf, None)
class Win32Context(Context):
def __init__(self, config, share):
super(Win32Context, self).__init__(config, share)
self._context = None
def attach(self, canvas):
super(Win32Context, self).attach(canvas)
if not self._context:
if self.config._requires_gl_3():
raise gl.ContextException(
'Require WGL_ARB_create_context extension to create ' +
'OpenGL 3 contexts.')
self.config._set_pixel_format(canvas)
self._context = wgl.wglCreateContext(canvas.hdc)
share = self.context_share
if share:
if not share.canvas:
raise RuntimeError('Share context has no canvas.')
if not wgl.wglShareLists(share._context, self._context):
raise gl.ContextException('Unable to share contexts')
def set_current(self):
if self._context is not None:
wgl.wglMakeCurrent(self.canvas.hdc, self._context)
super(Win32Context, self).set_current()
def detach(self):
if self.canvas:
wgl.wglDeleteContext(self._context)
self._context = None
super(Win32Context, self).detach()
def flip(self):
wgl.wglSwapLayerBuffers(self.canvas.hdc, wgl.WGL_SWAP_MAIN_PLANE)
def get_vsync(self):
if wgl_info.have_extension('WGL_EXT_swap_control'):
return bool(wglext_arb.wglGetSwapIntervalEXT())
def set_vsync(self, vsync):
if wgl_info.have_extension('WGL_EXT_swap_control'):
wglext_arb.wglSwapIntervalEXT(int(vsync))
class Win32ARBContext(Win32Context):
def __init__(self, config, share):
super(Win32ARBContext, self).__init__(config, share)
def attach(self, canvas):
share = self.context_share
if share:
if not share.canvas:
raise RuntimeError('Share context has no canvas.')
share = share._context
attribs = []
if self.config.major_version is not None:
attribs.extend([wglext_arb.WGL_CONTEXT_MAJOR_VERSION_ARB,
self.config.major_version])
if self.config.minor_version is not None:
attribs.extend([wglext_arb.WGL_CONTEXT_MINOR_VERSION_ARB,
self.config.minor_version])
flags = 0
if self.config.forward_compatible:
flags |= wglext_arb.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
if self.config.debug:
flags |= wglext_arb.WGL_DEBUG_BIT_ARB
if flags:
attribs.extend([wglext_arb.WGL_CONTEXT_FLAGS_ARB, flags])
attribs.append(0)
attribs = (c_int * len(attribs))(*attribs)
self.config._set_pixel_format(canvas)
self._context = wglext_arb.wglCreateContextAttribsARB(canvas.hdc,
share, attribs)
super(Win32ARBContext, self).attach(canvas)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Information about version and extensions of current GLX implementation.
Usage::
from pyglet.gl import glx_info
if glx_info.have_extension('GLX_NV_float_buffer'):
# ...
Or, if using more than one display::
from pyglet.gl.glx_info import GLXInfo
info = GLXInfo(window._display)
if info.get_server_vendor() == 'ATI':
# ...
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.glx import *
from pyglet.compat import asstr
class GLXInfoException(Exception):
pass
class GLXInfo(object):
def __init__(self, display=None):
# Set default display if not set
if display and not _glx_info.display:
_glx_info.set_display(display)
self.display = display
def set_display(self, display):
self.display = display
def check_display(self):
if not self.display:
raise GLXInfoException('No X11 display has been set yet.')
def have_version(self, major, minor=0):
self.check_display()
if not glXQueryExtension(self.display, None, None):
raise GLXInfoException('pyglet requires an X server with GLX')
server_version = self.get_server_version().split()[0]
client_version = self.get_client_version().split()[0]
server = [int(i) for i in server_version.split('.')]
client = [int(i) for i in client_version.split('.')]
return (tuple(server) >= (major, minor) and
tuple(client) >= (major, minor))
def get_server_vendor(self):
self.check_display()
return asstr(glXQueryServerString(self.display, 0, GLX_VENDOR))
def get_server_version(self):
# glXQueryServerString was introduced in GLX 1.1, so we need to use the
# 1.0 function here which queries the server implementation for its
# version.
self.check_display()
major = c_int()
minor = c_int()
if not glXQueryVersion(self.display, byref(major), byref(minor)):
raise GLXInfoException('Could not determine GLX server version')
return '%s.%s'%(major.value, minor.value)
def get_server_extensions(self):
self.check_display()
return asstr(glXQueryServerString(self.display, 0, GLX_EXTENSIONS)).split()
def get_client_vendor(self):
self.check_display()
return asstr(glXGetClientString(self.display, GLX_VENDOR))
def get_client_version(self):
self.check_display()
return asstr(glXGetClientString(self.display, GLX_VERSION))
def get_client_extensions(self):
self.check_display()
return asstr(glXGetClientString(self.display, GLX_EXTENSIONS)).split()
def get_extensions(self):
self.check_display()
return asstr(glXQueryExtensionsString(self.display, 0)).split()
def have_extension(self, extension):
self.check_display()
if not self.have_version(1, 1):
return False
return extension in self.get_extensions()
# Single instance suitable for apps that use only a single display.
_glx_info = GLXInfo()
set_display = _glx_info.set_display
check_display = _glx_info.check_display
have_version = _glx_info.have_version
get_server_vendor = _glx_info.get_server_vendor
get_server_version = _glx_info.get_server_version
get_server_extensions = _glx_info.get_server_extensions
get_client_vendor = _glx_info.get_client_vendor
get_client_version = _glx_info.get_client_version
get_client_extensions = _glx_info.get_client_extensions
get_extensions = _glx_info.get_extensions
have_extension = _glx_info.have_extension
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''This file is currently hand-coded; I don't have a MESA header file to build
off.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
from ctypes import *
from pyglet.gl.lib import link_GLX as _link_function
glXSwapIntervalMESA = _link_function('glXSwapIntervalMESA', c_int, [c_int], 'MESA_swap_control')
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://developer.download.nvidia.com/opengl/includes/glxext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GLX as _link_function
from pyglet.gl.lib import c_ptrdiff_t
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for http://developer.download.nvidia.com/opengl/includes/glxext.h
import pyglet.libs.x11.xlib
import pyglet.gl.glx
# H (/usr/include/GL/glx.h:26)
# ARB_get_proc_address (/usr/include/GL/glx.h:317)
# GLXEXT_LEGACY (/usr/include/GL/glx.h:334)
GLX_GLXEXT_VERSION = 10 # GL/glxext.h:57
# ARB_get_proc_address (GL/glxext.h:59)
# ARB_multisample (GL/glxext.h:62)
GLX_SAMPLE_BUFFERS_ARB = 100000 # GL/glxext.h:63
GLX_SAMPLES_ARB = 100001 # GL/glxext.h:64
# ARB_fbconfig_float (GL/glxext.h:67)
GLX_RGBA_FLOAT_TYPE_ARB = 8377 # GL/glxext.h:68
GLX_RGBA_FLOAT_BIT_ARB = 4 # GL/glxext.h:69
# SGIS_multisample (GL/glxext.h:72)
GLX_SAMPLE_BUFFERS_SGIS = 100000 # GL/glxext.h:73
GLX_SAMPLES_SGIS = 100001 # GL/glxext.h:74
# EXT_visual_info (GL/glxext.h:77)
GLX_X_VISUAL_TYPE_EXT = 34 # GL/glxext.h:78
GLX_TRANSPARENT_TYPE_EXT = 35 # GL/glxext.h:79
GLX_TRANSPARENT_INDEX_VALUE_EXT = 36 # GL/glxext.h:80
GLX_TRANSPARENT_RED_VALUE_EXT = 37 # GL/glxext.h:81
GLX_TRANSPARENT_GREEN_VALUE_EXT = 38 # GL/glxext.h:82
GLX_TRANSPARENT_BLUE_VALUE_EXT = 39 # GL/glxext.h:83
GLX_TRANSPARENT_ALPHA_VALUE_EXT = 40 # GL/glxext.h:84
GLX_NONE_EXT = 32768 # GL/glxext.h:85
GLX_TRUE_COLOR_EXT = 32770 # GL/glxext.h:86
GLX_DIRECT_COLOR_EXT = 32771 # GL/glxext.h:87
GLX_PSEUDO_COLOR_EXT = 32772 # GL/glxext.h:88
GLX_STATIC_COLOR_EXT = 32773 # GL/glxext.h:89
GLX_GRAY_SCALE_EXT = 32774 # GL/glxext.h:90
GLX_STATIC_GRAY_EXT = 32775 # GL/glxext.h:91
GLX_TRANSPARENT_RGB_EXT = 32776 # GL/glxext.h:92
GLX_TRANSPARENT_INDEX_EXT = 32777 # GL/glxext.h:93
# SGI_swap_control (GL/glxext.h:96)
# SGI_video_sync (GL/glxext.h:99)
# SGI_make_current_read (GL/glxext.h:102)
# SGIX_video_source (GL/glxext.h:105)
# EXT_visual_rating (GL/glxext.h:108)
GLX_VISUAL_CAVEAT_EXT = 32 # GL/glxext.h:109
GLX_SLOW_VISUAL_EXT = 32769 # GL/glxext.h:110
GLX_NON_CONFORMANT_VISUAL_EXT = 32781 # GL/glxext.h:111
# EXT_import_context (GL/glxext.h:115)
GLX_SHARE_CONTEXT_EXT = 32778 # GL/glxext.h:116
GLX_VISUAL_ID_EXT = 32779 # GL/glxext.h:117
GLX_SCREEN_EXT = 32780 # GL/glxext.h:118
# SGIX_fbconfig (GL/glxext.h:121)
GLX_WINDOW_BIT_SGIX = 1 # GL/glxext.h:122
GLX_PIXMAP_BIT_SGIX = 2 # GL/glxext.h:123
GLX_RGBA_BIT_SGIX = 1 # GL/glxext.h:124
GLX_COLOR_INDEX_BIT_SGIX = 2 # GL/glxext.h:125
GLX_DRAWABLE_TYPE_SGIX = 32784 # GL/glxext.h:126
GLX_RENDER_TYPE_SGIX = 32785 # GL/glxext.h:127
GLX_X_RENDERABLE_SGIX = 32786 # GL/glxext.h:128
GLX_FBCONFIG_ID_SGIX = 32787 # GL/glxext.h:129
GLX_RGBA_TYPE_SGIX = 32788 # GL/glxext.h:130
GLX_COLOR_INDEX_TYPE_SGIX = 32789 # GL/glxext.h:131
# SGIX_pbuffer (GL/glxext.h:135)
GLX_PBUFFER_BIT_SGIX = 4 # GL/glxext.h:136
GLX_BUFFER_CLOBBER_MASK_SGIX = 134217728 # GL/glxext.h:137
GLX_FRONT_LEFT_BUFFER_BIT_SGIX = 1 # GL/glxext.h:138
GLX_FRONT_RIGHT_BUFFER_BIT_SGIX = 2 # GL/glxext.h:139
GLX_BACK_LEFT_BUFFER_BIT_SGIX = 4 # GL/glxext.h:140
GLX_BACK_RIGHT_BUFFER_BIT_SGIX = 8 # GL/glxext.h:141
GLX_AUX_BUFFERS_BIT_SGIX = 16 # GL/glxext.h:142
GLX_DEPTH_BUFFER_BIT_SGIX = 32 # GL/glxext.h:143
GLX_STENCIL_BUFFER_BIT_SGIX = 64 # GL/glxext.h:144
GLX_ACCUM_BUFFER_BIT_SGIX = 128 # GL/glxext.h:145
GLX_SAMPLE_BUFFERS_BIT_SGIX = 256 # GL/glxext.h:146
GLX_MAX_PBUFFER_WIDTH_SGIX = 32790 # GL/glxext.h:147
GLX_MAX_PBUFFER_HEIGHT_SGIX = 32791 # GL/glxext.h:148
GLX_MAX_PBUFFER_PIXELS_SGIX = 32792 # GL/glxext.h:149
GLX_OPTIMAL_PBUFFER_WIDTH_SGIX = 32793 # GL/glxext.h:150
GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX = 32794 # GL/glxext.h:151
GLX_PRESERVED_CONTENTS_SGIX = 32795 # GL/glxext.h:152
GLX_LARGEST_PBUFFER_SGIX = 32796 # GL/glxext.h:153
GLX_WIDTH_SGIX = 32797 # GL/glxext.h:154
GLX_HEIGHT_SGIX = 32798 # GL/glxext.h:155
GLX_EVENT_MASK_SGIX = 32799 # GL/glxext.h:156
GLX_DAMAGED_SGIX = 32800 # GL/glxext.h:157
GLX_SAVED_SGIX = 32801 # GL/glxext.h:158
GLX_WINDOW_SGIX = 32802 # GL/glxext.h:159
GLX_PBUFFER_SGIX = 32803 # GL/glxext.h:160
# SGI_cushion (GL/glxext.h:163)
# SGIX_video_resize (GL/glxext.h:166)
GLX_SYNC_FRAME_SGIX = 0 # GL/glxext.h:167
GLX_SYNC_SWAP_SGIX = 1 # GL/glxext.h:168
# SGIX_dmbuffer (GL/glxext.h:171)
GLX_DIGITAL_MEDIA_PBUFFER_SGIX = 32804 # GL/glxext.h:172
# SGIX_swap_group (GL/glxext.h:175)
# SGIX_swap_barrier (GL/glxext.h:178)
# SGIS_blended_overlay (GL/glxext.h:181)
GLX_BLENDED_RGBA_SGIS = 32805 # GL/glxext.h:182
# SGIS_shared_multisample (GL/glxext.h:185)
GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS = 32806 # GL/glxext.h:186
GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS = 32807 # GL/glxext.h:187
# SUN_get_transparent_index (GL/glxext.h:190)
# 3DFX_multisample (GL/glxext.h:193)
GLX_SAMPLE_BUFFERS_3DFX = 32848 # GL/glxext.h:194
GLX_SAMPLES_3DFX = 32849 # GL/glxext.h:195
# MESA_copy_sub_buffer (GL/glxext.h:198)
# MESA_pixmap_colormap (GL/glxext.h:201)
# MESA_release_buffers (GL/glxext.h:204)
# MESA_set_3dfx_mode (GL/glxext.h:207)
GLX_3DFX_WINDOW_MODE_MESA = 1 # GL/glxext.h:208
GLX_3DFX_FULLSCREEN_MODE_MESA = 2 # GL/glxext.h:209
# SGIX_visual_select_group (GL/glxext.h:212)
GLX_VISUAL_SELECT_GROUP_SGIX = 32808 # GL/glxext.h:213
# OML_swap_method (GL/glxext.h:216)
GLX_SWAP_METHOD_OML = 32864 # GL/glxext.h:217
GLX_SWAP_EXCHANGE_OML = 32865 # GL/glxext.h:218
GLX_SWAP_COPY_OML = 32866 # GL/glxext.h:219
GLX_SWAP_UNDEFINED_OML = 32867 # GL/glxext.h:220
# OML_sync_control (GL/glxext.h:223)
# NV_float_buffer (GL/glxext.h:226)
GLX_FLOAT_COMPONENTS_NV = 8368 # GL/glxext.h:227
# SGIX_hyperpipe (GL/glxext.h:230)
GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX = 80 # GL/glxext.h:231
GLX_BAD_HYPERPIPE_CONFIG_SGIX = 91 # GL/glxext.h:232
GLX_BAD_HYPERPIPE_SGIX = 92 # GL/glxext.h:233
GLX_HYPERPIPE_DISPLAY_PIPE_SGIX = 1 # GL/glxext.h:234
GLX_HYPERPIPE_RENDER_PIPE_SGIX = 2 # GL/glxext.h:235
GLX_PIPE_RECT_SGIX = 1 # GL/glxext.h:236
GLX_PIPE_RECT_LIMITS_SGIX = 2 # GL/glxext.h:237
GLX_HYPERPIPE_STEREO_SGIX = 3 # GL/glxext.h:238
GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX = 4 # GL/glxext.h:239
GLX_HYPERPIPE_ID_SGIX = 32816 # GL/glxext.h:240
# MESA_agp_offset (GL/glxext.h:243)
# ARB_get_proc_address (GL/glxext.h:249)
# SGIX_video_source (GL/glxext.h:256)
XID = pyglet.libs.x11.xlib.XID
GLXVideoSourceSGIX = XID # GL/glxext.h:257
# SGIX_fbconfig (GL/glxext.h:260)
GLXFBConfigIDSGIX = XID # GL/glxext.h:261
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
GLXFBConfigSGIX = POINTER(struct___GLXFBConfigRec) # GL/glxext.h:262
# SGIX_pbuffer (GL/glxext.h:265)
GLXPbufferSGIX = XID # GL/glxext.h:266
class struct_anon_106(Structure):
__slots__ = [
'type',
'serial',
'send_event',
'display',
'drawable',
'event_type',
'draw_type',
'mask',
'x',
'y',
'width',
'height',
'count',
]
Display = pyglet.libs.x11.xlib.Display
GLXDrawable = pyglet.gl.glx.GLXDrawable
struct_anon_106._fields_ = [
('type', c_int),
('serial', c_ulong),
('send_event', c_int),
('display', POINTER(Display)),
('drawable', GLXDrawable),
('event_type', c_int),
('draw_type', c_int),
('mask', c_uint),
('x', c_int),
('y', c_int),
('width', c_int),
('height', c_int),
('count', c_int),
]
GLXBufferClobberEventSGIX = struct_anon_106 # GL/glxext.h:279
# NV_swap_group (GL/glxext.h:282)
# NV_video_out (GL/glxext.h:285)
GLXVideoDeviceNV = c_uint # GL/glxext.h:290
GLX_VIDEO_OUT_COLOR_NV = 8387 # GL/glxext.h:293
GLX_VIDEO_OUT_ALPHA_NV = 8388 # GL/glxext.h:294
GLX_VIDEO_OUT_DEPTH_NV = 8389 # GL/glxext.h:295
GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV = 8390 # GL/glxext.h:296
GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV = 8391 # GL/glxext.h:297
GLX_VIDEO_OUT_FRAME_NV = 8392 # GL/glxext.h:300
GLX_VIDEO_OUT_FIELD_1_NV = 8393 # GL/glxext.h:301
GLX_VIDEO_OUT_FIELD_2_NV = 8394 # GL/glxext.h:302
# EXT_texture_from_pixmap (GL/glxext.h:305)
GLX_BIND_TO_TEXTURE_RGB_EXT = 8400 # GL/glxext.h:307
GLX_BIND_TO_TEXTURE_RGBA_EXT = 8401 # GL/glxext.h:308
GLX_BIND_TO_MIPMAP_TEXTURE_EXT = 8402 # GL/glxext.h:309
GLX_BIND_TO_TEXTURE_TARGETS_EXT = 8403 # GL/glxext.h:310
GLX_Y_INVERTED_EXT = 8404 # GL/glxext.h:311
GLX_TEXTURE_FORMAT_EXT = 8405 # GL/glxext.h:314
GLX_TEXTURE_TARGET_EXT = 8406 # GL/glxext.h:315
GLX_MIPMAP_TEXTURE_EXT = 8407 # GL/glxext.h:316
GLX_TEXTURE_FORMAT_NONE_EXT = 8408 # GL/glxext.h:319
GLX_TEXTURE_FORMAT_RGB_EXT = 8409 # GL/glxext.h:320
GLX_TEXTURE_FORMAT_RGBA_EXT = 8410 # GL/glxext.h:321
GLX_TEXTURE_1D_BIT_EXT = 1 # GL/glxext.h:324
GLX_TEXTURE_2D_BIT_EXT = 2 # GL/glxext.h:325
GLX_TEXTURE_RECTANGLE_BIT_EXT = 4 # GL/glxext.h:326
GLX_TEXTURE_1D_EXT = 8411 # GL/glxext.h:329
GLX_TEXTURE_2D_EXT = 8412 # GL/glxext.h:330
GLX_TEXTURE_RECTANGLE_EXT = 8413 # GL/glxext.h:331
GLX_FRONT_LEFT_EXT = 8414 # GL/glxext.h:337
GLX_FRONT_RIGHT_EXT = 8415 # GL/glxext.h:338
GLX_BACK_LEFT_EXT = 8416 # GL/glxext.h:339
GLX_BACK_RIGHT_EXT = 8417 # GL/glxext.h:340
GLX_FRONT_EXT = 8414 # GL/glxext.h:341
GLX_BACK_EXT = 8416 # GL/glxext.h:342
GLX_AUX0_EXT = 8418 # GL/glxext.h:343
GLX_AUX1_EXT = 8419 # GL/glxext.h:344
GLX_AUX2_EXT = 8420 # GL/glxext.h:345
GLX_AUX3_EXT = 8421 # GL/glxext.h:346
GLX_AUX4_EXT = 8422 # GL/glxext.h:347
GLX_AUX5_EXT = 8423 # GL/glxext.h:348
GLX_AUX6_EXT = 8424 # GL/glxext.h:349
GLX_AUX7_EXT = 8425 # GL/glxext.h:350
GLX_AUX8_EXT = 8426 # GL/glxext.h:351
GLX_AUX9_EXT = 8427 # GL/glxext.h:352
# ARB_get_proc_address (GL/glxext.h:373)
# ARB_multisample (GL/glxext.h:377)
GLX_ARB_multisample = 1 # GL/glxext.h:378
# ARB_fbconfig_float (GL/glxext.h:381)
GLX_ARB_fbconfig_float = 1 # GL/glxext.h:382
# SGIS_multisample (GL/glxext.h:385)
GLX_SGIS_multisample = 1 # GL/glxext.h:386
# EXT_visual_info (GL/glxext.h:389)
GLX_EXT_visual_info = 1 # GL/glxext.h:390
# SGI_swap_control (GL/glxext.h:393)
GLX_SGI_swap_control = 1 # GL/glxext.h:394
# GL/glxext.h:396
glXSwapIntervalSGI = _link_function('glXSwapIntervalSGI', c_int, [c_int], 'SGI_swap_control')
PFNGLXSWAPINTERVALSGIPROC = CFUNCTYPE(c_int, c_int) # GL/glxext.h:398
# SGI_video_sync (GL/glxext.h:401)
GLX_SGI_video_sync = 1 # GL/glxext.h:402
# GL/glxext.h:404
glXGetVideoSyncSGI = _link_function('glXGetVideoSyncSGI', c_int, [POINTER(c_uint)], 'SGI_video_sync')
# GL/glxext.h:405
glXWaitVideoSyncSGI = _link_function('glXWaitVideoSyncSGI', c_int, [c_int, c_int, POINTER(c_uint)], 'SGI_video_sync')
# GL/glxext.h:406
glXGetRefreshRateSGI = _link_function('glXGetRefreshRateSGI', c_int, [POINTER(c_uint)], 'SGI_video_sync')
PFNGLXGETVIDEOSYNCSGIPROC = CFUNCTYPE(c_int, POINTER(c_uint)) # GL/glxext.h:408
PFNGLXWAITVIDEOSYNCSGIPROC = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_uint)) # GL/glxext.h:409
PFNGLXGETREFRESHRATESGIPROC = CFUNCTYPE(c_int, POINTER(c_uint)) # GL/glxext.h:410
# SGI_make_current_read (GL/glxext.h:413)
GLX_SGI_make_current_read = 1 # GL/glxext.h:414
GLXContext = pyglet.gl.glx.GLXContext
# GL/glxext.h:416
glXMakeCurrentReadSGI = _link_function('glXMakeCurrentReadSGI', c_int, [POINTER(Display), GLXDrawable, GLXDrawable, GLXContext], 'SGI_make_current_read')
# GL/glxext.h:417
glXGetCurrentReadDrawableSGI = _link_function('glXGetCurrentReadDrawableSGI', GLXDrawable, [], 'SGI_make_current_read')
PFNGLXMAKECURRENTREADSGIPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, GLXDrawable, GLXContext) # GL/glxext.h:419
PFNGLXGETCURRENTREADDRAWABLESGIPROC = CFUNCTYPE(GLXDrawable) # GL/glxext.h:420
# SGIX_video_source (GL/glxext.h:423)
GLX_SGIX_video_source = 1 # GL/glxext.h:424
# EXT_visual_rating (GL/glxext.h:435)
GLX_EXT_visual_rating = 1 # GL/glxext.h:436
# EXT_import_context (GL/glxext.h:439)
GLX_EXT_import_context = 1 # GL/glxext.h:440
# GL/glxext.h:442
glXGetCurrentDisplayEXT = _link_function('glXGetCurrentDisplayEXT', POINTER(Display), [], 'EXT_import_context')
# GL/glxext.h:443
glXQueryContextInfoEXT = _link_function('glXQueryContextInfoEXT', c_int, [POINTER(Display), GLXContext, c_int, POINTER(c_int)], 'EXT_import_context')
GLXContextID = pyglet.gl.glx.GLXContextID
# GL/glxext.h:444
glXGetContextIDEXT = _link_function('glXGetContextIDEXT', GLXContextID, [GLXContext], 'EXT_import_context')
# GL/glxext.h:445
glXImportContextEXT = _link_function('glXImportContextEXT', GLXContext, [POINTER(Display), GLXContextID], 'EXT_import_context')
# GL/glxext.h:446
glXFreeContextEXT = _link_function('glXFreeContextEXT', None, [POINTER(Display), GLXContext], 'EXT_import_context')
PFNGLXGETCURRENTDISPLAYEXTPROC = CFUNCTYPE(POINTER(Display)) # GL/glxext.h:448
PFNGLXQUERYCONTEXTINFOEXTPROC = CFUNCTYPE(c_int, POINTER(Display), GLXContext, c_int, POINTER(c_int)) # GL/glxext.h:449
PFNGLXGETCONTEXTIDEXTPROC = CFUNCTYPE(GLXContextID, GLXContext) # GL/glxext.h:450
PFNGLXIMPORTCONTEXTEXTPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXContextID) # GL/glxext.h:451
PFNGLXFREECONTEXTEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXContext) # GL/glxext.h:452
# SGIX_fbconfig (GL/glxext.h:455)
GLX_SGIX_fbconfig = 1 # GL/glxext.h:456
# GL/glxext.h:458
glXGetFBConfigAttribSGIX = _link_function('glXGetFBConfigAttribSGIX', c_int, [POINTER(Display), GLXFBConfigSGIX, c_int, POINTER(c_int)], 'SGIX_fbconfig')
# GL/glxext.h:459
glXChooseFBConfigSGIX = _link_function('glXChooseFBConfigSGIX', POINTER(GLXFBConfigSGIX), [POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)], 'SGIX_fbconfig')
GLXPixmap = pyglet.gl.glx.GLXPixmap
Pixmap = pyglet.libs.x11.xlib.Pixmap
# GL/glxext.h:460
glXCreateGLXPixmapWithConfigSGIX = _link_function('glXCreateGLXPixmapWithConfigSGIX', GLXPixmap, [POINTER(Display), GLXFBConfigSGIX, Pixmap], 'SGIX_fbconfig')
# GL/glxext.h:461
glXCreateContextWithConfigSGIX = _link_function('glXCreateContextWithConfigSGIX', GLXContext, [POINTER(Display), GLXFBConfigSGIX, c_int, GLXContext, c_int], 'SGIX_fbconfig')
XVisualInfo = pyglet.libs.x11.xlib.XVisualInfo
# GL/glxext.h:462
glXGetVisualFromFBConfigSGIX = _link_function('glXGetVisualFromFBConfigSGIX', POINTER(XVisualInfo), [POINTER(Display), GLXFBConfigSGIX], 'SGIX_fbconfig')
# GL/glxext.h:463
glXGetFBConfigFromVisualSGIX = _link_function('glXGetFBConfigFromVisualSGIX', GLXFBConfigSGIX, [POINTER(Display), POINTER(XVisualInfo)], 'SGIX_fbconfig')
PFNGLXGETFBCONFIGATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), GLXFBConfigSGIX, c_int, POINTER(c_int)) # GL/glxext.h:465
PFNGLXCHOOSEFBCONFIGSGIXPROC = CFUNCTYPE(POINTER(GLXFBConfigSGIX), POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)) # GL/glxext.h:466
PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC = CFUNCTYPE(GLXPixmap, POINTER(Display), GLXFBConfigSGIX, Pixmap) # GL/glxext.h:467
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXFBConfigSGIX, c_int, GLXContext, c_int) # GL/glxext.h:468
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC = CFUNCTYPE(POINTER(XVisualInfo), POINTER(Display), GLXFBConfigSGIX) # GL/glxext.h:469
PFNGLXGETFBCONFIGFROMVISUALSGIXPROC = CFUNCTYPE(GLXFBConfigSGIX, POINTER(Display), POINTER(XVisualInfo)) # GL/glxext.h:470
# SGIX_pbuffer (GL/glxext.h:473)
GLX_SGIX_pbuffer = 1 # GL/glxext.h:474
# GL/glxext.h:476
glXCreateGLXPbufferSGIX = _link_function('glXCreateGLXPbufferSGIX', GLXPbufferSGIX, [POINTER(Display), GLXFBConfigSGIX, c_uint, c_uint, POINTER(c_int)], 'SGIX_pbuffer')
# GL/glxext.h:477
glXDestroyGLXPbufferSGIX = _link_function('glXDestroyGLXPbufferSGIX', None, [POINTER(Display), GLXPbufferSGIX], 'SGIX_pbuffer')
# GL/glxext.h:478
glXQueryGLXPbufferSGIX = _link_function('glXQueryGLXPbufferSGIX', c_int, [POINTER(Display), GLXPbufferSGIX, c_int, POINTER(c_uint)], 'SGIX_pbuffer')
# GL/glxext.h:479
glXSelectEventSGIX = _link_function('glXSelectEventSGIX', None, [POINTER(Display), GLXDrawable, c_ulong], 'SGIX_pbuffer')
# GL/glxext.h:480
glXGetSelectedEventSGIX = _link_function('glXGetSelectedEventSGIX', None, [POINTER(Display), GLXDrawable, POINTER(c_ulong)], 'SGIX_pbuffer')
PFNGLXCREATEGLXPBUFFERSGIXPROC = CFUNCTYPE(GLXPbufferSGIX, POINTER(Display), GLXFBConfigSGIX, c_uint, c_uint, POINTER(c_int)) # GL/glxext.h:482
PFNGLXDESTROYGLXPBUFFERSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXPbufferSGIX) # GL/glxext.h:483
PFNGLXQUERYGLXPBUFFERSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbufferSGIX, c_int, POINTER(c_uint)) # GL/glxext.h:484
PFNGLXSELECTEVENTSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_ulong) # GL/glxext.h:485
PFNGLXGETSELECTEDEVENTSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, POINTER(c_ulong)) # GL/glxext.h:486
# SGI_cushion (GL/glxext.h:489)
GLX_SGI_cushion = 1 # GL/glxext.h:490
Window = pyglet.libs.x11.xlib.Window
# GL/glxext.h:492
glXCushionSGI = _link_function('glXCushionSGI', None, [POINTER(Display), Window, c_float], 'SGI_cushion')
PFNGLXCUSHIONSGIPROC = CFUNCTYPE(None, POINTER(Display), Window, c_float) # GL/glxext.h:494
# SGIX_video_resize (GL/glxext.h:497)
GLX_SGIX_video_resize = 1 # GL/glxext.h:498
# GL/glxext.h:500
glXBindChannelToWindowSGIX = _link_function('glXBindChannelToWindowSGIX', c_int, [POINTER(Display), c_int, c_int, Window], 'SGIX_video_resize')
# GL/glxext.h:501
glXChannelRectSGIX = _link_function('glXChannelRectSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, c_int, c_int, c_int], 'SGIX_video_resize')
# GL/glxext.h:502
glXQueryChannelRectSGIX = _link_function('glXQueryChannelRectSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], 'SGIX_video_resize')
# GL/glxext.h:503
glXQueryChannelDeltasSGIX = _link_function('glXQueryChannelDeltasSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], 'SGIX_video_resize')
GLenum = c_uint # /usr/include/GL/gl.h:153
# GL/glxext.h:504
glXChannelRectSyncSGIX = _link_function('glXChannelRectSyncSGIX', c_int, [POINTER(Display), c_int, c_int, GLenum], 'SGIX_video_resize')
PFNGLXBINDCHANNELTOWINDOWSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, Window) # GL/glxext.h:506
PFNGLXCHANNELRECTSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, c_int, c_int, c_int) # GL/glxext.h:507
PFNGLXQUERYCHANNELRECTSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)) # GL/glxext.h:508
PFNGLXQUERYCHANNELDELTASSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)) # GL/glxext.h:509
PFNGLXCHANNELRECTSYNCSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, GLenum) # GL/glxext.h:510
# SGIX_dmbuffer (GL/glxext.h:513)
GLX_SGIX_dmbuffer = 1 # GL/glxext.h:514
# SGIX_swap_group (GL/glxext.h:523)
GLX_SGIX_swap_group = 1 # GL/glxext.h:524
# GL/glxext.h:526
glXJoinSwapGroupSGIX = _link_function('glXJoinSwapGroupSGIX', None, [POINTER(Display), GLXDrawable, GLXDrawable], 'SGIX_swap_group')
PFNGLXJOINSWAPGROUPSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, GLXDrawable) # GL/glxext.h:528
# SGIX_swap_barrier (GL/glxext.h:531)
GLX_SGIX_swap_barrier = 1 # GL/glxext.h:532
# GL/glxext.h:534
glXBindSwapBarrierSGIX = _link_function('glXBindSwapBarrierSGIX', None, [POINTER(Display), GLXDrawable, c_int], 'SGIX_swap_barrier')
# GL/glxext.h:535
glXQueryMaxSwapBarriersSGIX = _link_function('glXQueryMaxSwapBarriersSGIX', c_int, [POINTER(Display), c_int, POINTER(c_int)], 'SGIX_swap_barrier')
PFNGLXBINDSWAPBARRIERSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int) # GL/glxext.h:537
PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:538
# SUN_get_transparent_index (GL/glxext.h:541)
GLX_SUN_get_transparent_index = 1 # GL/glxext.h:542
# GL/glxext.h:544
glXGetTransparentIndexSUN = _link_function('glXGetTransparentIndexSUN', c_int, [POINTER(Display), Window, Window, POINTER(c_long)], 'SUN_get_transparent_index')
PFNGLXGETTRANSPARENTINDEXSUNPROC = CFUNCTYPE(c_int, POINTER(Display), Window, Window, POINTER(c_long)) # GL/glxext.h:546
# MESA_copy_sub_buffer (GL/glxext.h:549)
GLX_MESA_copy_sub_buffer = 1 # GL/glxext.h:550
# GL/glxext.h:552
glXCopySubBufferMESA = _link_function('glXCopySubBufferMESA', None, [POINTER(Display), GLXDrawable, c_int, c_int, c_int, c_int], 'MESA_copy_sub_buffer')
PFNGLXCOPYSUBBUFFERMESAPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int, c_int, c_int, c_int) # GL/glxext.h:554
# MESA_pixmap_colormap (GL/glxext.h:557)
GLX_MESA_pixmap_colormap = 1 # GL/glxext.h:558
Colormap = pyglet.libs.x11.xlib.Colormap
# GL/glxext.h:560
glXCreateGLXPixmapMESA = _link_function('glXCreateGLXPixmapMESA', GLXPixmap, [POINTER(Display), POINTER(XVisualInfo), Pixmap, Colormap], 'MESA_pixmap_colormap')
PFNGLXCREATEGLXPIXMAPMESAPROC = CFUNCTYPE(GLXPixmap, POINTER(Display), POINTER(XVisualInfo), Pixmap, Colormap) # GL/glxext.h:562
# MESA_release_buffers (GL/glxext.h:565)
GLX_MESA_release_buffers = 1 # GL/glxext.h:566
# GL/glxext.h:568
glXReleaseBuffersMESA = _link_function('glXReleaseBuffersMESA', c_int, [POINTER(Display), GLXDrawable], 'MESA_release_buffers')
PFNGLXRELEASEBUFFERSMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable) # GL/glxext.h:570
# MESA_set_3dfx_mode (GL/glxext.h:573)
GLX_MESA_set_3dfx_mode = 1 # GL/glxext.h:574
# GL/glxext.h:576
glXSet3DfxModeMESA = _link_function('glXSet3DfxModeMESA', c_int, [c_int], 'MESA_set_3dfx_mode')
PFNGLXSET3DFXMODEMESAPROC = CFUNCTYPE(c_int, c_int) # GL/glxext.h:578
# SGIX_visual_select_group (GL/glxext.h:581)
GLX_SGIX_visual_select_group = 1 # GL/glxext.h:582
# OML_swap_method (GL/glxext.h:585)
GLX_OML_swap_method = 1 # GL/glxext.h:586
# OML_sync_control (GL/glxext.h:589)
GLX_OML_sync_control = 1 # GL/glxext.h:590
# GL/glxext.h:592
glXGetSyncValuesOML = _link_function('glXGetSyncValuesOML', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
# GL/glxext.h:593
glXGetMscRateOML = _link_function('glXGetMscRateOML', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int32), POINTER(c_int32)], 'OML_sync_control')
# GL/glxext.h:594
glXSwapBuffersMscOML = _link_function('glXSwapBuffersMscOML', c_int64, [POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64], 'OML_sync_control')
# GL/glxext.h:595
glXWaitForMscOML = _link_function('glXWaitForMscOML', c_int, [POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
# GL/glxext.h:596
glXWaitForSbcOML = _link_function('glXWaitForSbcOML', c_int, [POINTER(Display), GLXDrawable, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
PFNGLXGETSYNCVALUESOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:598
PFNGLXGETMSCRATEOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_int32), POINTER(c_int32)) # GL/glxext.h:599
PFNGLXSWAPBUFFERSMSCOMLPROC = CFUNCTYPE(c_int64, POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64) # GL/glxext.h:600
PFNGLXWAITFORMSCOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:601
PFNGLXWAITFORSBCOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:602
# NV_float_buffer (GL/glxext.h:605)
GLX_NV_float_buffer = 1 # GL/glxext.h:606
# SGIX_hyperpipe (GL/glxext.h:609)
GLX_SGIX_hyperpipe = 1 # GL/glxext.h:610
class struct_anon_107(Structure):
__slots__ = [
'pipeName',
'networkId',
]
struct_anon_107._fields_ = [
('pipeName', c_char * 80),
('networkId', c_int),
]
GLXHyperpipeNetworkSGIX = struct_anon_107 # GL/glxext.h:615
class struct_anon_108(Structure):
__slots__ = [
'pipeName',
'channel',
'participationType',
'timeSlice',
]
struct_anon_108._fields_ = [
('pipeName', c_char * 80),
('channel', c_int),
('participationType', c_uint),
('timeSlice', c_int),
]
GLXHyperpipeConfigSGIX = struct_anon_108 # GL/glxext.h:623
class struct_anon_109(Structure):
__slots__ = [
'pipeName',
'srcXOrigin',
'srcYOrigin',
'srcWidth',
'srcHeight',
'destXOrigin',
'destYOrigin',
'destWidth',
'destHeight',
]
struct_anon_109._fields_ = [
('pipeName', c_char * 80),
('srcXOrigin', c_int),
('srcYOrigin', c_int),
('srcWidth', c_int),
('srcHeight', c_int),
('destXOrigin', c_int),
('destYOrigin', c_int),
('destWidth', c_int),
('destHeight', c_int),
]
GLXPipeRect = struct_anon_109 # GL/glxext.h:629
class struct_anon_110(Structure):
__slots__ = [
'pipeName',
'XOrigin',
'YOrigin',
'maxHeight',
'maxWidth',
]
struct_anon_110._fields_ = [
('pipeName', c_char * 80),
('XOrigin', c_int),
('YOrigin', c_int),
('maxHeight', c_int),
('maxWidth', c_int),
]
GLXPipeRectLimits = struct_anon_110 # GL/glxext.h:634
# GL/glxext.h:637
glXQueryHyperpipeNetworkSGIX = _link_function('glXQueryHyperpipeNetworkSGIX', POINTER(GLXHyperpipeNetworkSGIX), [POINTER(Display), POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:638
glXHyperpipeConfigSGIX = _link_function('glXHyperpipeConfigSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(GLXHyperpipeConfigSGIX), POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:639
glXQueryHyperpipeConfigSGIX = _link_function('glXQueryHyperpipeConfigSGIX', POINTER(GLXHyperpipeConfigSGIX), [POINTER(Display), c_int, POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:640
glXDestroyHyperpipeConfigSGIX = _link_function('glXDestroyHyperpipeConfigSGIX', c_int, [POINTER(Display), c_int], 'SGIX_hyperpipe')
# GL/glxext.h:641
glXBindHyperpipeSGIX = _link_function('glXBindHyperpipeSGIX', c_int, [POINTER(Display), c_int], 'SGIX_hyperpipe')
# GL/glxext.h:642
glXQueryHyperpipeBestAttribSGIX = _link_function('glXQueryHyperpipeBestAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None), POINTER(None)], 'SGIX_hyperpipe')
# GL/glxext.h:643
glXHyperpipeAttribSGIX = _link_function('glXHyperpipeAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None)], 'SGIX_hyperpipe')
# GL/glxext.h:644
glXQueryHyperpipeAttribSGIX = _link_function('glXQueryHyperpipeAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None)], 'SGIX_hyperpipe')
PFNGLXQUERYHYPERPIPENETWORKSGIXPROC = CFUNCTYPE(POINTER(GLXHyperpipeNetworkSGIX), POINTER(Display), POINTER(c_int)) # GL/glxext.h:646
PFNGLXHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(GLXHyperpipeConfigSGIX), POINTER(c_int)) # GL/glxext.h:647
PFNGLXQUERYHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(POINTER(GLXHyperpipeConfigSGIX), POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:648
PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:649
PFNGLXBINDHYPERPIPESGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:650
PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None), POINTER(None)) # GL/glxext.h:651
PFNGLXHYPERPIPEATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None)) # GL/glxext.h:652
PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None)) # GL/glxext.h:653
# MESA_agp_offset (GL/glxext.h:656)
GLX_MESA_agp_offset = 1 # GL/glxext.h:657
# GL/glxext.h:659
glXGetAGPOffsetMESA = _link_function('glXGetAGPOffsetMESA', c_uint, [POINTER(None)], 'MESA_agp_offset')
PFNGLXGETAGPOFFSETMESAPROC = CFUNCTYPE(c_uint, POINTER(None)) # GL/glxext.h:661
# NV_vertex_array_range (GL/glxext.h:667)
GLX_NV_vertex_array_range = 1 # GL/glxext.h:668
GLsizei = pyglet.gl.glx.GLsizei
GLfloat = pyglet.gl.glx.GLfloat
# GL/glxext.h:670
glXAllocateMemoryNV = _link_function('glXAllocateMemoryNV', POINTER(c_void), [GLsizei, GLfloat, GLfloat, GLfloat], 'NV_vertex_array_range')
GLvoid = pyglet.gl.glx.GLvoid
# GL/glxext.h:673
glXFreeMemoryNV = _link_function('glXFreeMemoryNV', None, [POINTER(GLvoid)], 'NV_vertex_array_range')
PFNGLXALLOCATEMEMORYNVPROC = pyglet.gl.glx.PFNGLXALLOCATEMEMORYNVPROC
PFNGLXFREEMEMORYNVPROC = pyglet.gl.glx.PFNGLXFREEMEMORYNVPROC
# NV_swap_group (GL/glxext.h:683)
GLX_NV_swap_group = 1 # GL/glxext.h:684
GLuint = pyglet.gl.glx.GLuint
# GL/glxext.h:686
glXJoinSwapGroupNV = _link_function('glXJoinSwapGroupNV', c_int, [POINTER(Display), GLXDrawable, GLuint], 'NV_swap_group')
# GL/glxext.h:689
glXBindSwapBarrierNV = _link_function('glXBindSwapBarrierNV', c_int, [POINTER(Display), GLuint, GLuint], 'NV_swap_group')
# GL/glxext.h:691
glXQuerySwapGroupNV = _link_function('glXQuerySwapGroupNV', c_int, [POINTER(Display), GLXDrawable, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:694
glXQueryMaxSwapGroupsNV = _link_function('glXQueryMaxSwapGroupsNV', c_int, [POINTER(Display), c_int, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:697
glXQueryFrameCountNV = _link_function('glXQueryFrameCountNV', c_int, [POINTER(Display), c_int, POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:699
glXResetFrameCountNV = _link_function('glXResetFrameCountNV', c_int, [POINTER(Display), c_int], 'NV_swap_group')
PFNGLXJOINSWAPGROUPNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, GLuint) # GL/glxext.h:701
PFNGLXBINDSWAPBARRIERNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLuint, GLuint) # GL/glxext.h:705
PFNGLXQUERYSWAPGROUPNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(GLuint), POINTER(GLuint)) # GL/glxext.h:709
PFNGLXQUERYMAXSWAPGROUPSNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(GLuint), POINTER(GLuint)) # GL/glxext.h:714
PFNGLXQUERYFRAMECOUNTNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(GLuint)) # GL/glxext.h:719
PFNGLXRESETFRAMECOUNTNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:723
# NV_video_out (GL/glxext.h:726)
GLX_NV_video_out = 1 # GL/glxext.h:727
# GL/glxext.h:729
glXGetVideoDeviceNV = _link_function('glXGetVideoDeviceNV', c_int, [POINTER(Display), c_int, c_int, POINTER(GLXVideoDeviceNV)], 'NV_video_out')
# GL/glxext.h:732
glXReleaseVideoDeviceNV = _link_function('glXReleaseVideoDeviceNV', c_int, [POINTER(Display), c_int, GLXVideoDeviceNV], 'NV_video_out')
GLXPbuffer = pyglet.gl.glx.GLXPbuffer
# GL/glxext.h:735
glXBindVideoImageNV = _link_function('glXBindVideoImageNV', c_int, [POINTER(Display), GLXVideoDeviceNV, GLXPbuffer, c_int], 'NV_video_out')
# GL/glxext.h:738
glXReleaseVideoImageNV = _link_function('glXReleaseVideoImageNV', c_int, [POINTER(Display), GLXPbuffer], 'NV_video_out')
GLboolean = c_ubyte # /usr/include/GL/gl.h:154
# GL/glxext.h:740
glXSendPbufferToVideoNV = _link_function('glXSendPbufferToVideoNV', c_int, [POINTER(Display), GLXPbuffer, c_int, POINTER(c_ulong), GLboolean], 'NV_video_out')
# GL/glxext.h:745
glXGetVideoInfoNV = _link_function('glXGetVideoInfoNV', c_int, [POINTER(Display), c_int, GLXVideoDeviceNV, POINTER(c_ulong), POINTER(c_ulong)], 'NV_video_out')
PFNGLXGETVIDEODEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(GLXVideoDeviceNV)) # GL/glxext.h:750
PFNGLXRELEASEVIDEODEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, GLXVideoDeviceNV) # GL/glxext.h:755
PFNGLXBINDVIDEOIMAGENVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXVideoDeviceNV, GLXPbuffer, c_int) # GL/glxext.h:759
PFNGLXRELEASEVIDEOIMAGENVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbuffer) # GL/glxext.h:764
PFNGLXSENDPBUFFERTOVIDEONVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbuffer, c_int, POINTER(c_ulong), GLboolean) # GL/glxext.h:767
PFNGLXGETVIDEOINFONVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, GLXVideoDeviceNV, POINTER(c_ulong), POINTER(c_ulong)) # GL/glxext.h:773
# EXT_texture_from_pixmap (GL/glxext.h:779)
# GL/glxext.h:782
glXBindTexImageEXT = _link_function('glXBindTexImageEXT', None, [POINTER(Display), GLXDrawable, c_int, POINTER(c_int)], 'EXT_texture_from_pixmap')
# GL/glxext.h:784
glXReleaseTextImageEXT = _link_function('glXReleaseTextImageEXT', None, [POINTER(Display), GLXDrawable, c_int], 'EXT_texture_from_pixmap')
PFNGLXBINDTEXIMAGEEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int, POINTER(c_int)) # GL/glxext.h:787
PFNGLXRELEASETEXIMAGEEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int) # GL/glxext.h:791
# NV_vertex_array_range (/usr/include/GL/glx.h:349)
# MESA_allocate_memory (/usr/include/GL/glx.h:363)
# ARB_render_texture (/usr/include/GL/glx.h:380)
# NV_float_buffer (/usr/include/GL/glx.h:393)
# MESA_swap_frame_usage (/usr/include/GL/glx.h:405)
# MESA_swap_control (/usr/include/GL/glx.h:425)
# EXT_texture_from_pixmap (/usr/include/GL/glx.h:442)
__all__ = ['GLX_GLXEXT_VERSION', 'GLX_SAMPLE_BUFFERS_ARB', 'GLX_SAMPLES_ARB',
'GLX_RGBA_FLOAT_TYPE_ARB', 'GLX_RGBA_FLOAT_BIT_ARB',
'GLX_SAMPLE_BUFFERS_SGIS', 'GLX_SAMPLES_SGIS', 'GLX_X_VISUAL_TYPE_EXT',
'GLX_TRANSPARENT_TYPE_EXT', 'GLX_TRANSPARENT_INDEX_VALUE_EXT',
'GLX_TRANSPARENT_RED_VALUE_EXT', 'GLX_TRANSPARENT_GREEN_VALUE_EXT',
'GLX_TRANSPARENT_BLUE_VALUE_EXT', 'GLX_TRANSPARENT_ALPHA_VALUE_EXT',
'GLX_NONE_EXT', 'GLX_TRUE_COLOR_EXT', 'GLX_DIRECT_COLOR_EXT',
'GLX_PSEUDO_COLOR_EXT', 'GLX_STATIC_COLOR_EXT', 'GLX_GRAY_SCALE_EXT',
'GLX_STATIC_GRAY_EXT', 'GLX_TRANSPARENT_RGB_EXT', 'GLX_TRANSPARENT_INDEX_EXT',
'GLX_VISUAL_CAVEAT_EXT', 'GLX_SLOW_VISUAL_EXT',
'GLX_NON_CONFORMANT_VISUAL_EXT', 'GLX_SHARE_CONTEXT_EXT', 'GLX_VISUAL_ID_EXT',
'GLX_SCREEN_EXT', 'GLX_WINDOW_BIT_SGIX', 'GLX_PIXMAP_BIT_SGIX',
'GLX_RGBA_BIT_SGIX', 'GLX_COLOR_INDEX_BIT_SGIX', 'GLX_DRAWABLE_TYPE_SGIX',
'GLX_RENDER_TYPE_SGIX', 'GLX_X_RENDERABLE_SGIX', 'GLX_FBCONFIG_ID_SGIX',
'GLX_RGBA_TYPE_SGIX', 'GLX_COLOR_INDEX_TYPE_SGIX', 'GLX_PBUFFER_BIT_SGIX',
'GLX_BUFFER_CLOBBER_MASK_SGIX', 'GLX_FRONT_LEFT_BUFFER_BIT_SGIX',
'GLX_FRONT_RIGHT_BUFFER_BIT_SGIX', 'GLX_BACK_LEFT_BUFFER_BIT_SGIX',
'GLX_BACK_RIGHT_BUFFER_BIT_SGIX', 'GLX_AUX_BUFFERS_BIT_SGIX',
'GLX_DEPTH_BUFFER_BIT_SGIX', 'GLX_STENCIL_BUFFER_BIT_SGIX',
'GLX_ACCUM_BUFFER_BIT_SGIX', 'GLX_SAMPLE_BUFFERS_BIT_SGIX',
'GLX_MAX_PBUFFER_WIDTH_SGIX', 'GLX_MAX_PBUFFER_HEIGHT_SGIX',
'GLX_MAX_PBUFFER_PIXELS_SGIX', 'GLX_OPTIMAL_PBUFFER_WIDTH_SGIX',
'GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX', 'GLX_PRESERVED_CONTENTS_SGIX',
'GLX_LARGEST_PBUFFER_SGIX', 'GLX_WIDTH_SGIX', 'GLX_HEIGHT_SGIX',
'GLX_EVENT_MASK_SGIX', 'GLX_DAMAGED_SGIX', 'GLX_SAVED_SGIX',
'GLX_WINDOW_SGIX', 'GLX_PBUFFER_SGIX', 'GLX_SYNC_FRAME_SGIX',
'GLX_SYNC_SWAP_SGIX', 'GLX_DIGITAL_MEDIA_PBUFFER_SGIX',
'GLX_BLENDED_RGBA_SGIS', 'GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS',
'GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS', 'GLX_SAMPLE_BUFFERS_3DFX',
'GLX_SAMPLES_3DFX', 'GLX_3DFX_WINDOW_MODE_MESA',
'GLX_3DFX_FULLSCREEN_MODE_MESA', 'GLX_VISUAL_SELECT_GROUP_SGIX',
'GLX_SWAP_METHOD_OML', 'GLX_SWAP_EXCHANGE_OML', 'GLX_SWAP_COPY_OML',
'GLX_SWAP_UNDEFINED_OML', 'GLX_FLOAT_COMPONENTS_NV',
'GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX', 'GLX_BAD_HYPERPIPE_CONFIG_SGIX',
'GLX_BAD_HYPERPIPE_SGIX', 'GLX_HYPERPIPE_DISPLAY_PIPE_SGIX',
'GLX_HYPERPIPE_RENDER_PIPE_SGIX', 'GLX_PIPE_RECT_SGIX',
'GLX_PIPE_RECT_LIMITS_SGIX', 'GLX_HYPERPIPE_STEREO_SGIX',
'GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX', 'GLX_HYPERPIPE_ID_SGIX',
'GLXVideoSourceSGIX', 'GLXFBConfigIDSGIX', 'GLXFBConfigSGIX',
'GLXPbufferSGIX', 'GLXBufferClobberEventSGIX', 'GLXVideoDeviceNV',
'GLX_VIDEO_OUT_COLOR_NV', 'GLX_VIDEO_OUT_ALPHA_NV', 'GLX_VIDEO_OUT_DEPTH_NV',
'GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV', 'GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV',
'GLX_VIDEO_OUT_FRAME_NV', 'GLX_VIDEO_OUT_FIELD_1_NV',
'GLX_VIDEO_OUT_FIELD_2_NV', 'GLX_BIND_TO_TEXTURE_RGB_EXT',
'GLX_BIND_TO_TEXTURE_RGBA_EXT', 'GLX_BIND_TO_MIPMAP_TEXTURE_EXT',
'GLX_BIND_TO_TEXTURE_TARGETS_EXT', 'GLX_Y_INVERTED_EXT',
'GLX_TEXTURE_FORMAT_EXT', 'GLX_TEXTURE_TARGET_EXT', 'GLX_MIPMAP_TEXTURE_EXT',
'GLX_TEXTURE_FORMAT_NONE_EXT', 'GLX_TEXTURE_FORMAT_RGB_EXT',
'GLX_TEXTURE_FORMAT_RGBA_EXT', 'GLX_TEXTURE_1D_BIT_EXT',
'GLX_TEXTURE_2D_BIT_EXT', 'GLX_TEXTURE_RECTANGLE_BIT_EXT',
'GLX_TEXTURE_1D_EXT', 'GLX_TEXTURE_2D_EXT', 'GLX_TEXTURE_RECTANGLE_EXT',
'GLX_FRONT_LEFT_EXT', 'GLX_FRONT_RIGHT_EXT', 'GLX_BACK_LEFT_EXT',
'GLX_BACK_RIGHT_EXT', 'GLX_FRONT_EXT', 'GLX_BACK_EXT', 'GLX_AUX0_EXT',
'GLX_AUX1_EXT', 'GLX_AUX2_EXT', 'GLX_AUX3_EXT', 'GLX_AUX4_EXT',
'GLX_AUX5_EXT', 'GLX_AUX6_EXT', 'GLX_AUX7_EXT', 'GLX_AUX8_EXT',
'GLX_AUX9_EXT', 'GLX_ARB_multisample', 'GLX_ARB_fbconfig_float',
'GLX_SGIS_multisample', 'GLX_EXT_visual_info', 'GLX_SGI_swap_control',
'glXSwapIntervalSGI', 'PFNGLXSWAPINTERVALSGIPROC', 'GLX_SGI_video_sync',
'glXGetVideoSyncSGI', 'glXWaitVideoSyncSGI', 'glXGetRefreshRateSGI',
'PFNGLXGETVIDEOSYNCSGIPROC', 'PFNGLXWAITVIDEOSYNCSGIPROC',
'PFNGLXGETREFRESHRATESGIPROC', 'GLX_SGI_make_current_read',
'glXMakeCurrentReadSGI', 'glXGetCurrentReadDrawableSGI',
'PFNGLXMAKECURRENTREADSGIPROC', 'PFNGLXGETCURRENTREADDRAWABLESGIPROC',
'GLX_SGIX_video_source', 'GLX_EXT_visual_rating', 'GLX_EXT_import_context',
'glXGetCurrentDisplayEXT', 'glXQueryContextInfoEXT', 'glXGetContextIDEXT',
'glXImportContextEXT', 'glXFreeContextEXT', 'PFNGLXGETCURRENTDISPLAYEXTPROC',
'PFNGLXQUERYCONTEXTINFOEXTPROC', 'PFNGLXGETCONTEXTIDEXTPROC',
'PFNGLXIMPORTCONTEXTEXTPROC', 'PFNGLXFREECONTEXTEXTPROC', 'GLX_SGIX_fbconfig',
'glXGetFBConfigAttribSGIX', 'glXChooseFBConfigSGIX',
'glXCreateGLXPixmapWithConfigSGIX', 'glXCreateContextWithConfigSGIX',
'glXGetVisualFromFBConfigSGIX', 'glXGetFBConfigFromVisualSGIX',
'PFNGLXGETFBCONFIGATTRIBSGIXPROC', 'PFNGLXCHOOSEFBCONFIGSGIXPROC',
'PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC',
'PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC',
'PFNGLXGETVISUALFROMFBCONFIGSGIXPROC', 'PFNGLXGETFBCONFIGFROMVISUALSGIXPROC',
'GLX_SGIX_pbuffer', 'glXCreateGLXPbufferSGIX', 'glXDestroyGLXPbufferSGIX',
'glXQueryGLXPbufferSGIX', 'glXSelectEventSGIX', 'glXGetSelectedEventSGIX',
'PFNGLXCREATEGLXPBUFFERSGIXPROC', 'PFNGLXDESTROYGLXPBUFFERSGIXPROC',
'PFNGLXQUERYGLXPBUFFERSGIXPROC', 'PFNGLXSELECTEVENTSGIXPROC',
'PFNGLXGETSELECTEDEVENTSGIXPROC', 'GLX_SGI_cushion', 'glXCushionSGI',
'PFNGLXCUSHIONSGIPROC', 'GLX_SGIX_video_resize', 'glXBindChannelToWindowSGIX',
'glXChannelRectSGIX', 'glXQueryChannelRectSGIX', 'glXQueryChannelDeltasSGIX',
'glXChannelRectSyncSGIX', 'PFNGLXBINDCHANNELTOWINDOWSGIXPROC',
'PFNGLXCHANNELRECTSGIXPROC', 'PFNGLXQUERYCHANNELRECTSGIXPROC',
'PFNGLXQUERYCHANNELDELTASSGIXPROC', 'PFNGLXCHANNELRECTSYNCSGIXPROC',
'GLX_SGIX_dmbuffer', 'GLX_SGIX_swap_group', 'glXJoinSwapGroupSGIX',
'PFNGLXJOINSWAPGROUPSGIXPROC', 'GLX_SGIX_swap_barrier',
'glXBindSwapBarrierSGIX', 'glXQueryMaxSwapBarriersSGIX',
'PFNGLXBINDSWAPBARRIERSGIXPROC', 'PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC',
'GLX_SUN_get_transparent_index', 'glXGetTransparentIndexSUN',
'PFNGLXGETTRANSPARENTINDEXSUNPROC', 'GLX_MESA_copy_sub_buffer',
'glXCopySubBufferMESA', 'PFNGLXCOPYSUBBUFFERMESAPROC',
'GLX_MESA_pixmap_colormap', 'glXCreateGLXPixmapMESA',
'PFNGLXCREATEGLXPIXMAPMESAPROC', 'GLX_MESA_release_buffers',
'glXReleaseBuffersMESA', 'PFNGLXRELEASEBUFFERSMESAPROC',
'GLX_MESA_set_3dfx_mode', 'glXSet3DfxModeMESA', 'PFNGLXSET3DFXMODEMESAPROC',
'GLX_SGIX_visual_select_group', 'GLX_OML_swap_method', 'GLX_OML_sync_control',
'glXGetSyncValuesOML', 'glXGetMscRateOML', 'glXSwapBuffersMscOML',
'glXWaitForMscOML', 'glXWaitForSbcOML', 'PFNGLXGETSYNCVALUESOMLPROC',
'PFNGLXGETMSCRATEOMLPROC', 'PFNGLXSWAPBUFFERSMSCOMLPROC',
'PFNGLXWAITFORMSCOMLPROC', 'PFNGLXWAITFORSBCOMLPROC', 'GLX_NV_float_buffer',
'GLX_SGIX_hyperpipe', 'GLXHyperpipeNetworkSGIX', 'GLXHyperpipeConfigSGIX',
'GLXPipeRect', 'GLXPipeRectLimits', 'glXQueryHyperpipeNetworkSGIX',
'glXHyperpipeConfigSGIX', 'glXQueryHyperpipeConfigSGIX',
'glXDestroyHyperpipeConfigSGIX', 'glXBindHyperpipeSGIX',
'glXQueryHyperpipeBestAttribSGIX', 'glXHyperpipeAttribSGIX',
'glXQueryHyperpipeAttribSGIX', 'PFNGLXQUERYHYPERPIPENETWORKSGIXPROC',
'PFNGLXHYPERPIPECONFIGSGIXPROC', 'PFNGLXQUERYHYPERPIPECONFIGSGIXPROC',
'PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC', 'PFNGLXBINDHYPERPIPESGIXPROC',
'PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC', 'PFNGLXHYPERPIPEATTRIBSGIXPROC',
'PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC', 'GLX_MESA_agp_offset',
'glXGetAGPOffsetMESA', 'PFNGLXGETAGPOFFSETMESAPROC',
'GLX_NV_vertex_array_range', 'glXAllocateMemoryNV', 'glXFreeMemoryNV',
'PFNGLXALLOCATEMEMORYNVPROC', 'PFNGLXFREEMEMORYNVPROC', 'GLX_NV_swap_group',
'glXJoinSwapGroupNV', 'glXBindSwapBarrierNV', 'glXQuerySwapGroupNV',
'glXQueryMaxSwapGroupsNV', 'glXQueryFrameCountNV', 'glXResetFrameCountNV',
'PFNGLXJOINSWAPGROUPNVPROC', 'PFNGLXBINDSWAPBARRIERNVPROC',
'PFNGLXQUERYSWAPGROUPNVPROC', 'PFNGLXQUERYMAXSWAPGROUPSNVPROC',
'PFNGLXQUERYFRAMECOUNTNVPROC', 'PFNGLXRESETFRAMECOUNTNVPROC',
'GLX_NV_video_out', 'glXGetVideoDeviceNV', 'glXReleaseVideoDeviceNV',
'glXBindVideoImageNV', 'glXReleaseVideoImageNV', 'glXSendPbufferToVideoNV',
'glXGetVideoInfoNV', 'PFNGLXGETVIDEODEVICENVPROC',
'PFNGLXRELEASEVIDEODEVICENVPROC', 'PFNGLXBINDVIDEOIMAGENVPROC',
'PFNGLXRELEASEVIDEOIMAGENVPROC', 'PFNGLXSENDPBUFFERTOVIDEONVPROC',
'PFNGLXGETVIDEOINFONVPROC', 'glXBindTexImageEXT', 'glXReleaseTextImageEXT',
'PFNGLXBINDTEXIMAGEEXTPROC', 'PFNGLXRELEASETEXIMAGEEXTPROC']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://developer.download.nvidia.com/opengl/includes/glext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GL as _link_function
from pyglet.gl.lib import c_ptrdiff_t
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by gengl.py.
# Wrapper for http://developer.download.nvidia.com/opengl/includes/glext.h
# ARB_multitexture (/usr/include/GL/gl.h:1962)
GL_GLEXT_VERSION = 44 # GL/glext.h:74
# VERSION_1_2 (GL/glext.h:76)
# ARB_imaging (GL/glext.h:120)
# VERSION_1_3 (GL/glext.h:198)
# VERSION_1_4 (GL/glext.h:297)
GL_BLEND_DST_RGB = 32968 # GL/glext.h:298
GL_BLEND_SRC_RGB = 32969 # GL/glext.h:299
GL_BLEND_DST_ALPHA = 32970 # GL/glext.h:300
GL_BLEND_SRC_ALPHA = 32971 # GL/glext.h:301
GL_POINT_SIZE_MIN = 33062 # GL/glext.h:302
GL_POINT_SIZE_MAX = 33063 # GL/glext.h:303
GL_POINT_FADE_THRESHOLD_SIZE = 33064 # GL/glext.h:304
GL_POINT_DISTANCE_ATTENUATION = 33065 # GL/glext.h:305
GL_GENERATE_MIPMAP = 33169 # GL/glext.h:306
GL_GENERATE_MIPMAP_HINT = 33170 # GL/glext.h:307
GL_DEPTH_COMPONENT16 = 33189 # GL/glext.h:308
GL_DEPTH_COMPONENT24 = 33190 # GL/glext.h:309
GL_DEPTH_COMPONENT32 = 33191 # GL/glext.h:310
GL_MIRRORED_REPEAT = 33648 # GL/glext.h:311
GL_FOG_COORDINATE_SOURCE = 33872 # GL/glext.h:312
GL_FOG_COORDINATE = 33873 # GL/glext.h:313
GL_FRAGMENT_DEPTH = 33874 # GL/glext.h:314
GL_CURRENT_FOG_COORDINATE = 33875 # GL/glext.h:315
GL_FOG_COORDINATE_ARRAY_TYPE = 33876 # GL/glext.h:316
GL_FOG_COORDINATE_ARRAY_STRIDE = 33877 # GL/glext.h:317
GL_FOG_COORDINATE_ARRAY_POINTER = 33878 # GL/glext.h:318
GL_FOG_COORDINATE_ARRAY = 33879 # GL/glext.h:319
GL_COLOR_SUM = 33880 # GL/glext.h:320
GL_CURRENT_SECONDARY_COLOR = 33881 # GL/glext.h:321
GL_SECONDARY_COLOR_ARRAY_SIZE = 33882 # GL/glext.h:322
GL_SECONDARY_COLOR_ARRAY_TYPE = 33883 # GL/glext.h:323
GL_SECONDARY_COLOR_ARRAY_STRIDE = 33884 # GL/glext.h:324
GL_SECONDARY_COLOR_ARRAY_POINTER = 33885 # GL/glext.h:325
GL_SECONDARY_COLOR_ARRAY = 33886 # GL/glext.h:326
GL_MAX_TEXTURE_LOD_BIAS = 34045 # GL/glext.h:327
GL_TEXTURE_FILTER_CONTROL = 34048 # GL/glext.h:328
GL_TEXTURE_LOD_BIAS = 34049 # GL/glext.h:329
GL_INCR_WRAP = 34055 # GL/glext.h:330
GL_DECR_WRAP = 34056 # GL/glext.h:331
GL_TEXTURE_DEPTH_SIZE = 34890 # GL/glext.h:332
GL_DEPTH_TEXTURE_MODE = 34891 # GL/glext.h:333
GL_TEXTURE_COMPARE_MODE = 34892 # GL/glext.h:334
GL_TEXTURE_COMPARE_FUNC = 34893 # GL/glext.h:335
GL_COMPARE_R_TO_TEXTURE = 34894 # GL/glext.h:336
# VERSION_1_5 (GL/glext.h:339)
GL_BUFFER_SIZE = 34660 # GL/glext.h:340
GL_BUFFER_USAGE = 34661 # GL/glext.h:341
GL_QUERY_COUNTER_BITS = 34916 # GL/glext.h:342
GL_CURRENT_QUERY = 34917 # GL/glext.h:343
GL_QUERY_RESULT = 34918 # GL/glext.h:344
GL_QUERY_RESULT_AVAILABLE = 34919 # GL/glext.h:345
GL_ARRAY_BUFFER = 34962 # GL/glext.h:346
GL_ELEMENT_ARRAY_BUFFER = 34963 # GL/glext.h:347
GL_ARRAY_BUFFER_BINDING = 34964 # GL/glext.h:348
GL_ELEMENT_ARRAY_BUFFER_BINDING = 34965 # GL/glext.h:349
GL_VERTEX_ARRAY_BUFFER_BINDING = 34966 # GL/glext.h:350
GL_NORMAL_ARRAY_BUFFER_BINDING = 34967 # GL/glext.h:351
GL_COLOR_ARRAY_BUFFER_BINDING = 34968 # GL/glext.h:352
GL_INDEX_ARRAY_BUFFER_BINDING = 34969 # GL/glext.h:353
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 34970 # GL/glext.h:354
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 34971 # GL/glext.h:355
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 34972 # GL/glext.h:356
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 34973 # GL/glext.h:357
GL_WEIGHT_ARRAY_BUFFER_BINDING = 34974 # GL/glext.h:358
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 34975 # GL/glext.h:359
GL_READ_ONLY = 35000 # GL/glext.h:360
GL_WRITE_ONLY = 35001 # GL/glext.h:361
GL_READ_WRITE = 35002 # GL/glext.h:362
GL_BUFFER_ACCESS = 35003 # GL/glext.h:363
GL_BUFFER_MAPPED = 35004 # GL/glext.h:364
GL_BUFFER_MAP_POINTER = 35005 # GL/glext.h:365
GL_STREAM_DRAW = 35040 # GL/glext.h:366
GL_STREAM_READ = 35041 # GL/glext.h:367
GL_STREAM_COPY = 35042 # GL/glext.h:368
GL_STATIC_DRAW = 35044 # GL/glext.h:369
GL_STATIC_READ = 35045 # GL/glext.h:370
GL_STATIC_COPY = 35046 # GL/glext.h:371
GL_DYNAMIC_DRAW = 35048 # GL/glext.h:372
GL_DYNAMIC_READ = 35049 # GL/glext.h:373
GL_DYNAMIC_COPY = 35050 # GL/glext.h:374
GL_SAMPLES_PASSED = 35092 # GL/glext.h:375
GL_FOG_COORD_SRC = 33872 # GL/glext.h:376
GL_FOG_COORD = 33873 # GL/glext.h:377
GL_CURRENT_FOG_COORD = 33875 # GL/glext.h:378
GL_FOG_COORD_ARRAY_TYPE = 33876 # GL/glext.h:379
GL_FOG_COORD_ARRAY_STRIDE = 33877 # GL/glext.h:380
GL_FOG_COORD_ARRAY_POINTER = 33878 # GL/glext.h:381
GL_FOG_COORD_ARRAY = 33879 # GL/glext.h:382
GL_FOG_COORD_ARRAY_BUFFER_BINDING = 34973 # GL/glext.h:383
GL_SRC0_RGB = 34176 # GL/glext.h:384
GL_SRC1_RGB = 34177 # GL/glext.h:385
GL_SRC2_RGB = 34178 # GL/glext.h:386
GL_SRC0_ALPHA = 34184 # GL/glext.h:387
GL_SRC1_ALPHA = 34185 # GL/glext.h:388
GL_SRC2_ALPHA = 34186 # GL/glext.h:389
# VERSION_2_0 (GL/glext.h:392)
GL_BLEND_EQUATION_RGB = 32777 # GL/glext.h:393
GL_VERTEX_ATTRIB_ARRAY_ENABLED = 34338 # GL/glext.h:394
GL_VERTEX_ATTRIB_ARRAY_SIZE = 34339 # GL/glext.h:395
GL_VERTEX_ATTRIB_ARRAY_STRIDE = 34340 # GL/glext.h:396
GL_VERTEX_ATTRIB_ARRAY_TYPE = 34341 # GL/glext.h:397
GL_CURRENT_VERTEX_ATTRIB = 34342 # GL/glext.h:398
GL_VERTEX_PROGRAM_POINT_SIZE = 34370 # GL/glext.h:399
GL_VERTEX_PROGRAM_TWO_SIDE = 34371 # GL/glext.h:400
GL_VERTEX_ATTRIB_ARRAY_POINTER = 34373 # GL/glext.h:401
GL_STENCIL_BACK_FUNC = 34816 # GL/glext.h:402
GL_STENCIL_BACK_FAIL = 34817 # GL/glext.h:403
GL_STENCIL_BACK_PASS_DEPTH_FAIL = 34818 # GL/glext.h:404
GL_STENCIL_BACK_PASS_DEPTH_PASS = 34819 # GL/glext.h:405
GL_MAX_DRAW_BUFFERS = 34852 # GL/glext.h:406
GL_DRAW_BUFFER0 = 34853 # GL/glext.h:407
GL_DRAW_BUFFER1 = 34854 # GL/glext.h:408
GL_DRAW_BUFFER2 = 34855 # GL/glext.h:409
GL_DRAW_BUFFER3 = 34856 # GL/glext.h:410
GL_DRAW_BUFFER4 = 34857 # GL/glext.h:411
GL_DRAW_BUFFER5 = 34858 # GL/glext.h:412
GL_DRAW_BUFFER6 = 34859 # GL/glext.h:413
GL_DRAW_BUFFER7 = 34860 # GL/glext.h:414
GL_DRAW_BUFFER8 = 34861 # GL/glext.h:415
GL_DRAW_BUFFER9 = 34862 # GL/glext.h:416
GL_DRAW_BUFFER10 = 34863 # GL/glext.h:417
GL_DRAW_BUFFER11 = 34864 # GL/glext.h:418
GL_DRAW_BUFFER12 = 34865 # GL/glext.h:419
GL_DRAW_BUFFER13 = 34866 # GL/glext.h:420
GL_DRAW_BUFFER14 = 34867 # GL/glext.h:421
GL_DRAW_BUFFER15 = 34868 # GL/glext.h:422
GL_BLEND_EQUATION_ALPHA = 34877 # GL/glext.h:423
GL_POINT_SPRITE = 34913 # GL/glext.h:424
GL_COORD_REPLACE = 34914 # GL/glext.h:425
GL_MAX_VERTEX_ATTRIBS = 34921 # GL/glext.h:426
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922 # GL/glext.h:427
GL_MAX_TEXTURE_COORDS = 34929 # GL/glext.h:428
GL_MAX_TEXTURE_IMAGE_UNITS = 34930 # GL/glext.h:429
GL_FRAGMENT_SHADER = 35632 # GL/glext.h:430
GL_VERTEX_SHADER = 35633 # GL/glext.h:431
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 35657 # GL/glext.h:432
GL_MAX_VERTEX_UNIFORM_COMPONENTS = 35658 # GL/glext.h:433
GL_MAX_VARYING_FLOATS = 35659 # GL/glext.h:434
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660 # GL/glext.h:435
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661 # GL/glext.h:436
GL_SHADER_TYPE = 35663 # GL/glext.h:437
GL_FLOAT_VEC2 = 35664 # GL/glext.h:438
GL_FLOAT_VEC3 = 35665 # GL/glext.h:439
GL_FLOAT_VEC4 = 35666 # GL/glext.h:440
GL_INT_VEC2 = 35667 # GL/glext.h:441
GL_INT_VEC3 = 35668 # GL/glext.h:442
GL_INT_VEC4 = 35669 # GL/glext.h:443
GL_BOOL = 35670 # GL/glext.h:444
GL_BOOL_VEC2 = 35671 # GL/glext.h:445
GL_BOOL_VEC3 = 35672 # GL/glext.h:446
GL_BOOL_VEC4 = 35673 # GL/glext.h:447
GL_FLOAT_MAT2 = 35674 # GL/glext.h:448
GL_FLOAT_MAT3 = 35675 # GL/glext.h:449
GL_FLOAT_MAT4 = 35676 # GL/glext.h:450
GL_SAMPLER_1D = 35677 # GL/glext.h:451
GL_SAMPLER_2D = 35678 # GL/glext.h:452
GL_SAMPLER_3D = 35679 # GL/glext.h:453
GL_SAMPLER_CUBE = 35680 # GL/glext.h:454
GL_SAMPLER_1D_SHADOW = 35681 # GL/glext.h:455
GL_SAMPLER_2D_SHADOW = 35682 # GL/glext.h:456
GL_DELETE_STATUS = 35712 # GL/glext.h:457
GL_COMPILE_STATUS = 35713 # GL/glext.h:458
GL_LINK_STATUS = 35714 # GL/glext.h:459
GL_VALIDATE_STATUS = 35715 # GL/glext.h:460
GL_INFO_LOG_LENGTH = 35716 # GL/glext.h:461
GL_ATTACHED_SHADERS = 35717 # GL/glext.h:462
GL_ACTIVE_UNIFORMS = 35718 # GL/glext.h:463
GL_ACTIVE_UNIFORM_MAX_LENGTH = 35719 # GL/glext.h:464
GL_SHADER_SOURCE_LENGTH = 35720 # GL/glext.h:465
GL_ACTIVE_ATTRIBUTES = 35721 # GL/glext.h:466
GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 35722 # GL/glext.h:467
GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 35723 # GL/glext.h:468
GL_SHADING_LANGUAGE_VERSION = 35724 # GL/glext.h:469
GL_CURRENT_PROGRAM = 35725 # GL/glext.h:470
GL_POINT_SPRITE_COORD_ORIGIN = 36000 # GL/glext.h:471
GL_LOWER_LEFT = 36001 # GL/glext.h:472
GL_UPPER_LEFT = 36002 # GL/glext.h:473
GL_STENCIL_BACK_REF = 36003 # GL/glext.h:474
GL_STENCIL_BACK_VALUE_MASK = 36004 # GL/glext.h:475
GL_STENCIL_BACK_WRITEMASK = 36005 # GL/glext.h:476
# VERSION_2_1 (GL/glext.h:479)
GL_PIXEL_PACK_BUFFER = 35051 # GL/glext.h:480
GL_PIXEL_UNPACK_BUFFER = 35052 # GL/glext.h:481
GL_PIXEL_PACK_BUFFER_BINDING = 35053 # GL/glext.h:482
GL_PIXEL_UNPACK_BUFFER_BINDING = 35055 # GL/glext.h:483
GL_SRGB = 35904 # GL/glext.h:484
GL_SRGB8 = 35905 # GL/glext.h:485
GL_SRGB_ALPHA = 35906 # GL/glext.h:486
GL_SRGB8_ALPHA8 = 35907 # GL/glext.h:487
GL_SLUMINANCE_ALPHA = 35908 # GL/glext.h:488
GL_SLUMINANCE8_ALPHA8 = 35909 # GL/glext.h:489
GL_SLUMINANCE = 35910 # GL/glext.h:490
GL_SLUMINANCE8 = 35911 # GL/glext.h:491
GL_COMPRESSED_SRGB = 35912 # GL/glext.h:492
GL_COMPRESSED_SRGB_ALPHA = 35913 # GL/glext.h:493
GL_COMPRESSED_SLUMINANCE = 35914 # GL/glext.h:494
GL_COMPRESSED_SLUMINANCE_ALPHA = 35915 # GL/glext.h:495
GL_FLOAT_MAT2x3 = 35685 # GL/glext.h:496
GL_FLOAT_MAT2x4 = 35686 # GL/glext.h:497
GL_FLOAT_MAT3x2 = 35687 # GL/glext.h:498
GL_FLOAT_MAT3x4 = 35688 # GL/glext.h:499
GL_FLOAT_MAT4x2 = 35689 # GL/glext.h:500
GL_FLOAT_MAT4x3 = 35690 # GL/glext.h:501
GL_CURRENT_RASTER_SECONDARY_COLOR = 33887 # GL/glext.h:502
# VERSION_3_0 (GL/glext.h:505)
GL_CLIP_DISTANCE0 = 12288 # GL/glext.h:507
GL_CLIP_DISTANCE1 = 12289 # GL/glext.h:508
GL_CLIP_DISTANCE2 = 12290 # GL/glext.h:509
GL_CLIP_DISTANCE3 = 12291 # GL/glext.h:510
GL_CLIP_DISTANCE4 = 12292 # GL/glext.h:511
GL_CLIP_DISTANCE5 = 12293 # GL/glext.h:512
GL_MAX_CLIP_DISTANCES = 3378 # GL/glext.h:513
GL_MAJOR_VERSION = 33307 # GL/glext.h:514
GL_MINOR_VERSION = 33308 # GL/glext.h:515
GL_NUM_EXTENSIONS = 33309 # GL/glext.h:516
GL_CONTEXT_FLAGS = 33310 # GL/glext.h:517
GL_DEPTH_BUFFER = 33315 # GL/glext.h:518
GL_STENCIL_BUFFER = 33316 # GL/glext.h:519
GL_COMPRESSED_RED = 33317 # GL/glext.h:520
GL_COMPRESSED_RG = 33318 # GL/glext.h:521
GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 1 # GL/glext.h:522
GL_RGBA32F = 34836 # GL/glext.h:523
GL_RGB32F = 34837 # GL/glext.h:524
GL_RGBA16F = 34842 # GL/glext.h:525
GL_RGB16F = 34843 # GL/glext.h:526
GL_VERTEX_ATTRIB_ARRAY_INTEGER = 35069 # GL/glext.h:527
GL_MAX_ARRAY_TEXTURE_LAYERS = 35071 # GL/glext.h:528
GL_MIN_PROGRAM_TEXEL_OFFSET = 35076 # GL/glext.h:529
GL_MAX_PROGRAM_TEXEL_OFFSET = 35077 # GL/glext.h:530
GL_CLAMP_VERTEX_COLOR = 35098 # GL/glext.h:531
GL_CLAMP_FRAGMENT_COLOR = 35099 # GL/glext.h:532
GL_CLAMP_READ_COLOR = 35100 # GL/glext.h:533
GL_FIXED_ONLY = 35101 # GL/glext.h:534
GL_MAX_VARYING_COMPONENTS = 35659 # GL/glext.h:535
GL_TEXTURE_RED_TYPE = 35856 # GL/glext.h:536
GL_TEXTURE_GREEN_TYPE = 35857 # GL/glext.h:537
GL_TEXTURE_BLUE_TYPE = 35858 # GL/glext.h:538
GL_TEXTURE_ALPHA_TYPE = 35859 # GL/glext.h:539
GL_TEXTURE_LUMINANCE_TYPE = 35860 # GL/glext.h:540
GL_TEXTURE_INTENSITY_TYPE = 35861 # GL/glext.h:541
GL_TEXTURE_DEPTH_TYPE = 35862 # GL/glext.h:542
GL_UNSIGNED_NORMALIZED = 35863 # GL/glext.h:543
GL_TEXTURE_1D_ARRAY = 35864 # GL/glext.h:544
GL_PROXY_TEXTURE_1D_ARRAY = 35865 # GL/glext.h:545
GL_TEXTURE_2D_ARRAY = 35866 # GL/glext.h:546
GL_PROXY_TEXTURE_2D_ARRAY = 35867 # GL/glext.h:547
GL_TEXTURE_BINDING_1D_ARRAY = 35868 # GL/glext.h:548
GL_TEXTURE_BINDING_2D_ARRAY = 35869 # GL/glext.h:549
GL_R11F_G11F_B10F = 35898 # GL/glext.h:550
GL_UNSIGNED_INT_10F_11F_11F_REV = 35899 # GL/glext.h:551
GL_RGB9_E5 = 35901 # GL/glext.h:552
GL_UNSIGNED_INT_5_9_9_9_REV = 35902 # GL/glext.h:553
GL_TEXTURE_SHARED_SIZE = 35903 # GL/glext.h:554
GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 35958 # GL/glext.h:555
GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 35967 # GL/glext.h:556
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 35968 # GL/glext.h:557
GL_TRANSFORM_FEEDBACK_VARYINGS = 35971 # GL/glext.h:558
GL_TRANSFORM_FEEDBACK_BUFFER_START = 35972 # GL/glext.h:559
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 35973 # GL/glext.h:560
GL_PRIMITIVES_GENERATED = 35975 # GL/glext.h:561
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976 # GL/glext.h:562
GL_RASTERIZER_DISCARD = 35977 # GL/glext.h:563
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 35978 # GL/glext.h:564
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 35979 # GL/glext.h:565
GL_INTERLEAVED_ATTRIBS = 35980 # GL/glext.h:566
GL_SEPARATE_ATTRIBS = 35981 # GL/glext.h:567
GL_TRANSFORM_FEEDBACK_BUFFER = 35982 # GL/glext.h:568
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 35983 # GL/glext.h:569
GL_RGBA32UI = 36208 # GL/glext.h:570
GL_RGB32UI = 36209 # GL/glext.h:571
GL_RGBA16UI = 36214 # GL/glext.h:572
GL_RGB16UI = 36215 # GL/glext.h:573
GL_RGBA8UI = 36220 # GL/glext.h:574
GL_RGB8UI = 36221 # GL/glext.h:575
GL_RGBA32I = 36226 # GL/glext.h:576
GL_RGB32I = 36227 # GL/glext.h:577
GL_RGBA16I = 36232 # GL/glext.h:578
GL_RGB16I = 36233 # GL/glext.h:579
GL_RGBA8I = 36238 # GL/glext.h:580
GL_RGB8I = 36239 # GL/glext.h:581
GL_RED_INTEGER = 36244 # GL/glext.h:582
GL_GREEN_INTEGER = 36245 # GL/glext.h:583
GL_BLUE_INTEGER = 36246 # GL/glext.h:584
GL_ALPHA_INTEGER = 36247 # GL/glext.h:585
GL_RGB_INTEGER = 36248 # GL/glext.h:586
GL_RGBA_INTEGER = 36249 # GL/glext.h:587
GL_BGR_INTEGER = 36250 # GL/glext.h:588
GL_BGRA_INTEGER = 36251 # GL/glext.h:589
GL_SAMPLER_1D_ARRAY = 36288 # GL/glext.h:590
GL_SAMPLER_2D_ARRAY = 36289 # GL/glext.h:591
GL_SAMPLER_1D_ARRAY_SHADOW = 36291 # GL/glext.h:592
GL_SAMPLER_2D_ARRAY_SHADOW = 36292 # GL/glext.h:593
GL_SAMPLER_CUBE_SHADOW = 36293 # GL/glext.h:594
GL_UNSIGNED_INT_VEC2 = 36294 # GL/glext.h:595
GL_UNSIGNED_INT_VEC3 = 36295 # GL/glext.h:596
GL_UNSIGNED_INT_VEC4 = 36296 # GL/glext.h:597
GL_INT_SAMPLER_1D = 36297 # GL/glext.h:598
GL_INT_SAMPLER_2D = 36298 # GL/glext.h:599
GL_INT_SAMPLER_3D = 36299 # GL/glext.h:600
GL_INT_SAMPLER_CUBE = 36300 # GL/glext.h:601
GL_INT_SAMPLER_1D_ARRAY = 36302 # GL/glext.h:602
GL_INT_SAMPLER_2D_ARRAY = 36303 # GL/glext.h:603
GL_UNSIGNED_INT_SAMPLER_1D = 36305 # GL/glext.h:604
GL_UNSIGNED_INT_SAMPLER_2D = 36306 # GL/glext.h:605
GL_UNSIGNED_INT_SAMPLER_3D = 36307 # GL/glext.h:606
GL_UNSIGNED_INT_SAMPLER_CUBE = 36308 # GL/glext.h:607
GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 36310 # GL/glext.h:608
GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 36311 # GL/glext.h:609
GL_QUERY_WAIT = 36371 # GL/glext.h:610
GL_QUERY_NO_WAIT = 36372 # GL/glext.h:611
GL_QUERY_BY_REGION_WAIT = 36373 # GL/glext.h:612
GL_QUERY_BY_REGION_NO_WAIT = 36374 # GL/glext.h:613
# ARB_multitexture (GL/glext.h:742)
# ARB_transpose_matrix (GL/glext.h:780)
GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 34019 # GL/glext.h:781
GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 34020 # GL/glext.h:782
GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 34021 # GL/glext.h:783
GL_TRANSPOSE_COLOR_MATRIX_ARB = 34022 # GL/glext.h:784
# ARB_multisample (GL/glext.h:787)
GL_MULTISAMPLE_ARB = 32925 # GL/glext.h:788
GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 32926 # GL/glext.h:789
GL_SAMPLE_ALPHA_TO_ONE_ARB = 32927 # GL/glext.h:790
GL_SAMPLE_COVERAGE_ARB = 32928 # GL/glext.h:791
GL_SAMPLE_BUFFERS_ARB = 32936 # GL/glext.h:792
GL_SAMPLES_ARB = 32937 # GL/glext.h:793
GL_SAMPLE_COVERAGE_VALUE_ARB = 32938 # GL/glext.h:794
GL_SAMPLE_COVERAGE_INVERT_ARB = 32939 # GL/glext.h:795
GL_MULTISAMPLE_BIT_ARB = 536870912 # GL/glext.h:796
# ARB_texture_env_add (GL/glext.h:799)
# ARB_texture_cube_map (GL/glext.h:802)
GL_NORMAL_MAP_ARB = 34065 # GL/glext.h:803
GL_REFLECTION_MAP_ARB = 34066 # GL/glext.h:804
GL_TEXTURE_CUBE_MAP_ARB = 34067 # GL/glext.h:805
GL_TEXTURE_BINDING_CUBE_MAP_ARB = 34068 # GL/glext.h:806
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 34069 # GL/glext.h:807
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 34070 # GL/glext.h:808
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 34071 # GL/glext.h:809
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 34072 # GL/glext.h:810
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 34073 # GL/glext.h:811
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 34074 # GL/glext.h:812
GL_PROXY_TEXTURE_CUBE_MAP_ARB = 34075 # GL/glext.h:813
GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 34076 # GL/glext.h:814
# ARB_texture_compression (GL/glext.h:817)
GL_COMPRESSED_ALPHA_ARB = 34025 # GL/glext.h:818
GL_COMPRESSED_LUMINANCE_ARB = 34026 # GL/glext.h:819
GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 34027 # GL/glext.h:820
GL_COMPRESSED_INTENSITY_ARB = 34028 # GL/glext.h:821
GL_COMPRESSED_RGB_ARB = 34029 # GL/glext.h:822
GL_COMPRESSED_RGBA_ARB = 34030 # GL/glext.h:823
GL_TEXTURE_COMPRESSION_HINT_ARB = 34031 # GL/glext.h:824
GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 34464 # GL/glext.h:825
GL_TEXTURE_COMPRESSED_ARB = 34465 # GL/glext.h:826
GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 34466 # GL/glext.h:827
GL_COMPRESSED_TEXTURE_FORMATS_ARB = 34467 # GL/glext.h:828
# ARB_texture_border_clamp (GL/glext.h:831)
GL_CLAMP_TO_BORDER_ARB = 33069 # GL/glext.h:832
# ARB_point_parameters (GL/glext.h:835)
GL_POINT_SIZE_MIN_ARB = 33062 # GL/glext.h:836
GL_POINT_SIZE_MAX_ARB = 33063 # GL/glext.h:837
GL_POINT_FADE_THRESHOLD_SIZE_ARB = 33064 # GL/glext.h:838
GL_POINT_DISTANCE_ATTENUATION_ARB = 33065 # GL/glext.h:839
# ARB_vertex_blend (GL/glext.h:842)
GL_MAX_VERTEX_UNITS_ARB = 34468 # GL/glext.h:843
GL_ACTIVE_VERTEX_UNITS_ARB = 34469 # GL/glext.h:844
GL_WEIGHT_SUM_UNITY_ARB = 34470 # GL/glext.h:845
GL_VERTEX_BLEND_ARB = 34471 # GL/glext.h:846
GL_CURRENT_WEIGHT_ARB = 34472 # GL/glext.h:847
GL_WEIGHT_ARRAY_TYPE_ARB = 34473 # GL/glext.h:848
GL_WEIGHT_ARRAY_STRIDE_ARB = 34474 # GL/glext.h:849
GL_WEIGHT_ARRAY_SIZE_ARB = 34475 # GL/glext.h:850
GL_WEIGHT_ARRAY_POINTER_ARB = 34476 # GL/glext.h:851
GL_WEIGHT_ARRAY_ARB = 34477 # GL/glext.h:852
GL_MODELVIEW0_ARB = 5888 # GL/glext.h:853
GL_MODELVIEW1_ARB = 34058 # GL/glext.h:854
GL_MODELVIEW2_ARB = 34594 # GL/glext.h:855
GL_MODELVIEW3_ARB = 34595 # GL/glext.h:856
GL_MODELVIEW4_ARB = 34596 # GL/glext.h:857
GL_MODELVIEW5_ARB = 34597 # GL/glext.h:858
GL_MODELVIEW6_ARB = 34598 # GL/glext.h:859
GL_MODELVIEW7_ARB = 34599 # GL/glext.h:860
GL_MODELVIEW8_ARB = 34600 # GL/glext.h:861
GL_MODELVIEW9_ARB = 34601 # GL/glext.h:862
GL_MODELVIEW10_ARB = 34602 # GL/glext.h:863
GL_MODELVIEW11_ARB = 34603 # GL/glext.h:864
GL_MODELVIEW12_ARB = 34604 # GL/glext.h:865
GL_MODELVIEW13_ARB = 34605 # GL/glext.h:866
GL_MODELVIEW14_ARB = 34606 # GL/glext.h:867
GL_MODELVIEW15_ARB = 34607 # GL/glext.h:868
GL_MODELVIEW16_ARB = 34608 # GL/glext.h:869
GL_MODELVIEW17_ARB = 34609 # GL/glext.h:870
GL_MODELVIEW18_ARB = 34610 # GL/glext.h:871
GL_MODELVIEW19_ARB = 34611 # GL/glext.h:872
GL_MODELVIEW20_ARB = 34612 # GL/glext.h:873
GL_MODELVIEW21_ARB = 34613 # GL/glext.h:874
GL_MODELVIEW22_ARB = 34614 # GL/glext.h:875
GL_MODELVIEW23_ARB = 34615 # GL/glext.h:876
GL_MODELVIEW24_ARB = 34616 # GL/glext.h:877
GL_MODELVIEW25_ARB = 34617 # GL/glext.h:878
GL_MODELVIEW26_ARB = 34618 # GL/glext.h:879
GL_MODELVIEW27_ARB = 34619 # GL/glext.h:880
GL_MODELVIEW28_ARB = 34620 # GL/glext.h:881
GL_MODELVIEW29_ARB = 34621 # GL/glext.h:882
GL_MODELVIEW30_ARB = 34622 # GL/glext.h:883
GL_MODELVIEW31_ARB = 34623 # GL/glext.h:884
# ARB_matrix_palette (GL/glext.h:887)
GL_MATRIX_PALETTE_ARB = 34880 # GL/glext.h:888
GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 34881 # GL/glext.h:889
GL_MAX_PALETTE_MATRICES_ARB = 34882 # GL/glext.h:890
GL_CURRENT_PALETTE_MATRIX_ARB = 34883 # GL/glext.h:891
GL_MATRIX_INDEX_ARRAY_ARB = 34884 # GL/glext.h:892
GL_CURRENT_MATRIX_INDEX_ARB = 34885 # GL/glext.h:893
GL_MATRIX_INDEX_ARRAY_SIZE_ARB = 34886 # GL/glext.h:894
GL_MATRIX_INDEX_ARRAY_TYPE_ARB = 34887 # GL/glext.h:895
GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = 34888 # GL/glext.h:896
GL_MATRIX_INDEX_ARRAY_POINTER_ARB = 34889 # GL/glext.h:897
# ARB_texture_env_combine (GL/glext.h:900)
GL_COMBINE_ARB = 34160 # GL/glext.h:901
GL_COMBINE_RGB_ARB = 34161 # GL/glext.h:902
GL_COMBINE_ALPHA_ARB = 34162 # GL/glext.h:903
GL_SOURCE0_RGB_ARB = 34176 # GL/glext.h:904
GL_SOURCE1_RGB_ARB = 34177 # GL/glext.h:905
GL_SOURCE2_RGB_ARB = 34178 # GL/glext.h:906
GL_SOURCE0_ALPHA_ARB = 34184 # GL/glext.h:907
GL_SOURCE1_ALPHA_ARB = 34185 # GL/glext.h:908
GL_SOURCE2_ALPHA_ARB = 34186 # GL/glext.h:909
GL_OPERAND0_RGB_ARB = 34192 # GL/glext.h:910
GL_OPERAND1_RGB_ARB = 34193 # GL/glext.h:911
GL_OPERAND2_RGB_ARB = 34194 # GL/glext.h:912
GL_OPERAND0_ALPHA_ARB = 34200 # GL/glext.h:913
GL_OPERAND1_ALPHA_ARB = 34201 # GL/glext.h:914
GL_OPERAND2_ALPHA_ARB = 34202 # GL/glext.h:915
GL_RGB_SCALE_ARB = 34163 # GL/glext.h:916
GL_ADD_SIGNED_ARB = 34164 # GL/glext.h:917
GL_INTERPOLATE_ARB = 34165 # GL/glext.h:918
GL_SUBTRACT_ARB = 34023 # GL/glext.h:919
GL_CONSTANT_ARB = 34166 # GL/glext.h:920
GL_PRIMARY_COLOR_ARB = 34167 # GL/glext.h:921
GL_PREVIOUS_ARB = 34168 # GL/glext.h:922
# ARB_texture_env_crossbar (GL/glext.h:925)
# ARB_texture_env_dot3 (GL/glext.h:928)
GL_DOT3_RGB_ARB = 34478 # GL/glext.h:929
GL_DOT3_RGBA_ARB = 34479 # GL/glext.h:930
# ARB_texture_mirrored_repeat (GL/glext.h:933)
GL_MIRRORED_REPEAT_ARB = 33648 # GL/glext.h:934
# ARB_depth_texture (GL/glext.h:937)
GL_DEPTH_COMPONENT16_ARB = 33189 # GL/glext.h:938
GL_DEPTH_COMPONENT24_ARB = 33190 # GL/glext.h:939
GL_DEPTH_COMPONENT32_ARB = 33191 # GL/glext.h:940
GL_TEXTURE_DEPTH_SIZE_ARB = 34890 # GL/glext.h:941
GL_DEPTH_TEXTURE_MODE_ARB = 34891 # GL/glext.h:942
# ARB_shadow (GL/glext.h:945)
GL_TEXTURE_COMPARE_MODE_ARB = 34892 # GL/glext.h:946
GL_TEXTURE_COMPARE_FUNC_ARB = 34893 # GL/glext.h:947
GL_COMPARE_R_TO_TEXTURE_ARB = 34894 # GL/glext.h:948
# ARB_shadow_ambient (GL/glext.h:951)
GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 32959 # GL/glext.h:952
# ARB_window_pos (GL/glext.h:955)
# ARB_vertex_program (GL/glext.h:958)
GL_COLOR_SUM_ARB = 33880 # GL/glext.h:959
GL_VERTEX_PROGRAM_ARB = 34336 # GL/glext.h:960
GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 34338 # GL/glext.h:961
GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 34339 # GL/glext.h:962
GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 34340 # GL/glext.h:963
GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 34341 # GL/glext.h:964
GL_CURRENT_VERTEX_ATTRIB_ARB = 34342 # GL/glext.h:965
GL_PROGRAM_LENGTH_ARB = 34343 # GL/glext.h:966
GL_PROGRAM_STRING_ARB = 34344 # GL/glext.h:967
GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 34350 # GL/glext.h:968
GL_MAX_PROGRAM_MATRICES_ARB = 34351 # GL/glext.h:969
GL_CURRENT_MATRIX_STACK_DEPTH_ARB = 34368 # GL/glext.h:970
GL_CURRENT_MATRIX_ARB = 34369 # GL/glext.h:971
GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 34370 # GL/glext.h:972
GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 34371 # GL/glext.h:973
GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 34373 # GL/glext.h:974
GL_PROGRAM_ERROR_POSITION_ARB = 34379 # GL/glext.h:975
GL_PROGRAM_BINDING_ARB = 34423 # GL/glext.h:976
GL_MAX_VERTEX_ATTRIBS_ARB = 34921 # GL/glext.h:977
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 34922 # GL/glext.h:978
GL_PROGRAM_ERROR_STRING_ARB = 34932 # GL/glext.h:979
GL_PROGRAM_FORMAT_ASCII_ARB = 34933 # GL/glext.h:980
GL_PROGRAM_FORMAT_ARB = 34934 # GL/glext.h:981
GL_PROGRAM_INSTRUCTIONS_ARB = 34976 # GL/glext.h:982
GL_MAX_PROGRAM_INSTRUCTIONS_ARB = 34977 # GL/glext.h:983
GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 34978 # GL/glext.h:984
GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 34979 # GL/glext.h:985
GL_PROGRAM_TEMPORARIES_ARB = 34980 # GL/glext.h:986
GL_MAX_PROGRAM_TEMPORARIES_ARB = 34981 # GL/glext.h:987
GL_PROGRAM_NATIVE_TEMPORARIES_ARB = 34982 # GL/glext.h:988
GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 34983 # GL/glext.h:989
GL_PROGRAM_PARAMETERS_ARB = 34984 # GL/glext.h:990
GL_MAX_PROGRAM_PARAMETERS_ARB = 34985 # GL/glext.h:991
GL_PROGRAM_NATIVE_PARAMETERS_ARB = 34986 # GL/glext.h:992
GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 34987 # GL/glext.h:993
GL_PROGRAM_ATTRIBS_ARB = 34988 # GL/glext.h:994
GL_MAX_PROGRAM_ATTRIBS_ARB = 34989 # GL/glext.h:995
GL_PROGRAM_NATIVE_ATTRIBS_ARB = 34990 # GL/glext.h:996
GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 34991 # GL/glext.h:997
GL_PROGRAM_ADDRESS_REGISTERS_ARB = 34992 # GL/glext.h:998
GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 34993 # GL/glext.h:999
GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 34994 # GL/glext.h:1000
GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 34995 # GL/glext.h:1001
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 34996 # GL/glext.h:1002
GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = 34997 # GL/glext.h:1003
GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 34998 # GL/glext.h:1004
GL_TRANSPOSE_CURRENT_MATRIX_ARB = 34999 # GL/glext.h:1005
GL_MATRIX0_ARB = 35008 # GL/glext.h:1006
GL_MATRIX1_ARB = 35009 # GL/glext.h:1007
GL_MATRIX2_ARB = 35010 # GL/glext.h:1008
GL_MATRIX3_ARB = 35011 # GL/glext.h:1009
GL_MATRIX4_ARB = 35012 # GL/glext.h:1010
GL_MATRIX5_ARB = 35013 # GL/glext.h:1011
GL_MATRIX6_ARB = 35014 # GL/glext.h:1012
GL_MATRIX7_ARB = 35015 # GL/glext.h:1013
GL_MATRIX8_ARB = 35016 # GL/glext.h:1014
GL_MATRIX9_ARB = 35017 # GL/glext.h:1015
GL_MATRIX10_ARB = 35018 # GL/glext.h:1016
GL_MATRIX11_ARB = 35019 # GL/glext.h:1017
GL_MATRIX12_ARB = 35020 # GL/glext.h:1018
GL_MATRIX13_ARB = 35021 # GL/glext.h:1019
GL_MATRIX14_ARB = 35022 # GL/glext.h:1020
GL_MATRIX15_ARB = 35023 # GL/glext.h:1021
GL_MATRIX16_ARB = 35024 # GL/glext.h:1022
GL_MATRIX17_ARB = 35025 # GL/glext.h:1023
GL_MATRIX18_ARB = 35026 # GL/glext.h:1024
GL_MATRIX19_ARB = 35027 # GL/glext.h:1025
GL_MATRIX20_ARB = 35028 # GL/glext.h:1026
GL_MATRIX21_ARB = 35029 # GL/glext.h:1027
GL_MATRIX22_ARB = 35030 # GL/glext.h:1028
GL_MATRIX23_ARB = 35031 # GL/glext.h:1029
GL_MATRIX24_ARB = 35032 # GL/glext.h:1030
GL_MATRIX25_ARB = 35033 # GL/glext.h:1031
GL_MATRIX26_ARB = 35034 # GL/glext.h:1032
GL_MATRIX27_ARB = 35035 # GL/glext.h:1033
GL_MATRIX28_ARB = 35036 # GL/glext.h:1034
GL_MATRIX29_ARB = 35037 # GL/glext.h:1035
GL_MATRIX30_ARB = 35038 # GL/glext.h:1036
GL_MATRIX31_ARB = 35039 # GL/glext.h:1037
# ARB_fragment_program (GL/glext.h:1040)
GL_FRAGMENT_PROGRAM_ARB = 34820 # GL/glext.h:1041
GL_PROGRAM_ALU_INSTRUCTIONS_ARB = 34821 # GL/glext.h:1042
GL_PROGRAM_TEX_INSTRUCTIONS_ARB = 34822 # GL/glext.h:1043
GL_PROGRAM_TEX_INDIRECTIONS_ARB = 34823 # GL/glext.h:1044
GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34824 # GL/glext.h:1045
GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34825 # GL/glext.h:1046
GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34826 # GL/glext.h:1047
GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 34827 # GL/glext.h:1048
GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 34828 # GL/glext.h:1049
GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 34829 # GL/glext.h:1050
GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34830 # GL/glext.h:1051
GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34831 # GL/glext.h:1052
GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34832 # GL/glext.h:1053
GL_MAX_TEXTURE_COORDS_ARB = 34929 # GL/glext.h:1054
GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 34930 # GL/glext.h:1055
# ARB_vertex_buffer_object (GL/glext.h:1058)
GL_BUFFER_SIZE_ARB = 34660 # GL/glext.h:1059
GL_BUFFER_USAGE_ARB = 34661 # GL/glext.h:1060
GL_ARRAY_BUFFER_ARB = 34962 # GL/glext.h:1061
GL_ELEMENT_ARRAY_BUFFER_ARB = 34963 # GL/glext.h:1062
GL_ARRAY_BUFFER_BINDING_ARB = 34964 # GL/glext.h:1063
GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 34965 # GL/glext.h:1064
GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 34966 # GL/glext.h:1065
GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 34967 # GL/glext.h:1066
GL_COLOR_ARRAY_BUFFER_BINDING_ARB = 34968 # GL/glext.h:1067
GL_INDEX_ARRAY_BUFFER_BINDING_ARB = 34969 # GL/glext.h:1068
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 34970 # GL/glext.h:1069
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 34971 # GL/glext.h:1070
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 34972 # GL/glext.h:1071
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 34973 # GL/glext.h:1072
GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 34974 # GL/glext.h:1073
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 34975 # GL/glext.h:1074
GL_READ_ONLY_ARB = 35000 # GL/glext.h:1075
GL_WRITE_ONLY_ARB = 35001 # GL/glext.h:1076
GL_READ_WRITE_ARB = 35002 # GL/glext.h:1077
GL_BUFFER_ACCESS_ARB = 35003 # GL/glext.h:1078
GL_BUFFER_MAPPED_ARB = 35004 # GL/glext.h:1079
GL_BUFFER_MAP_POINTER_ARB = 35005 # GL/glext.h:1080
GL_STREAM_DRAW_ARB = 35040 # GL/glext.h:1081
GL_STREAM_READ_ARB = 35041 # GL/glext.h:1082
GL_STREAM_COPY_ARB = 35042 # GL/glext.h:1083
GL_STATIC_DRAW_ARB = 35044 # GL/glext.h:1084
GL_STATIC_READ_ARB = 35045 # GL/glext.h:1085
GL_STATIC_COPY_ARB = 35046 # GL/glext.h:1086
GL_DYNAMIC_DRAW_ARB = 35048 # GL/glext.h:1087
GL_DYNAMIC_READ_ARB = 35049 # GL/glext.h:1088
GL_DYNAMIC_COPY_ARB = 35050 # GL/glext.h:1089
# ARB_occlusion_query (GL/glext.h:1092)
GL_QUERY_COUNTER_BITS_ARB = 34916 # GL/glext.h:1093
GL_CURRENT_QUERY_ARB = 34917 # GL/glext.h:1094
GL_QUERY_RESULT_ARB = 34918 # GL/glext.h:1095
GL_QUERY_RESULT_AVAILABLE_ARB = 34919 # GL/glext.h:1096
GL_SAMPLES_PASSED_ARB = 35092 # GL/glext.h:1097
# ARB_shader_objects (GL/glext.h:1100)
GL_PROGRAM_OBJECT_ARB = 35648 # GL/glext.h:1101
GL_SHADER_OBJECT_ARB = 35656 # GL/glext.h:1102
GL_OBJECT_TYPE_ARB = 35662 # GL/glext.h:1103
GL_OBJECT_SUBTYPE_ARB = 35663 # GL/glext.h:1104
GL_FLOAT_VEC2_ARB = 35664 # GL/glext.h:1105
GL_FLOAT_VEC3_ARB = 35665 # GL/glext.h:1106
GL_FLOAT_VEC4_ARB = 35666 # GL/glext.h:1107
GL_INT_VEC2_ARB = 35667 # GL/glext.h:1108
GL_INT_VEC3_ARB = 35668 # GL/glext.h:1109
GL_INT_VEC4_ARB = 35669 # GL/glext.h:1110
GL_BOOL_ARB = 35670 # GL/glext.h:1111
GL_BOOL_VEC2_ARB = 35671 # GL/glext.h:1112
GL_BOOL_VEC3_ARB = 35672 # GL/glext.h:1113
GL_BOOL_VEC4_ARB = 35673 # GL/glext.h:1114
GL_FLOAT_MAT2_ARB = 35674 # GL/glext.h:1115
GL_FLOAT_MAT3_ARB = 35675 # GL/glext.h:1116
GL_FLOAT_MAT4_ARB = 35676 # GL/glext.h:1117
GL_SAMPLER_1D_ARB = 35677 # GL/glext.h:1118
GL_SAMPLER_2D_ARB = 35678 # GL/glext.h:1119
GL_SAMPLER_3D_ARB = 35679 # GL/glext.h:1120
GL_SAMPLER_CUBE_ARB = 35680 # GL/glext.h:1121
GL_SAMPLER_1D_SHADOW_ARB = 35681 # GL/glext.h:1122
GL_SAMPLER_2D_SHADOW_ARB = 35682 # GL/glext.h:1123
GL_SAMPLER_2D_RECT_ARB = 35683 # GL/glext.h:1124
GL_SAMPLER_2D_RECT_SHADOW_ARB = 35684 # GL/glext.h:1125
GL_OBJECT_DELETE_STATUS_ARB = 35712 # GL/glext.h:1126
GL_OBJECT_COMPILE_STATUS_ARB = 35713 # GL/glext.h:1127
GL_OBJECT_LINK_STATUS_ARB = 35714 # GL/glext.h:1128
GL_OBJECT_VALIDATE_STATUS_ARB = 35715 # GL/glext.h:1129
GL_OBJECT_INFO_LOG_LENGTH_ARB = 35716 # GL/glext.h:1130
GL_OBJECT_ATTACHED_OBJECTS_ARB = 35717 # GL/glext.h:1131
GL_OBJECT_ACTIVE_UNIFORMS_ARB = 35718 # GL/glext.h:1132
GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 35719 # GL/glext.h:1133
GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 35720 # GL/glext.h:1134
# ARB_vertex_shader (GL/glext.h:1137)
GL_VERTEX_SHADER_ARB = 35633 # GL/glext.h:1138
GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 35658 # GL/glext.h:1139
GL_MAX_VARYING_FLOATS_ARB = 35659 # GL/glext.h:1140
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 35660 # GL/glext.h:1141
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 35661 # GL/glext.h:1142
GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 35721 # GL/glext.h:1143
GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 35722 # GL/glext.h:1144
# ARB_fragment_shader (GL/glext.h:1147)
GL_FRAGMENT_SHADER_ARB = 35632 # GL/glext.h:1148
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 35657 # GL/glext.h:1149
GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 35723 # GL/glext.h:1150
# ARB_shading_language_100 (GL/glext.h:1153)
GL_SHADING_LANGUAGE_VERSION_ARB = 35724 # GL/glext.h:1154
# ARB_texture_non_power_of_two (GL/glext.h:1157)
# ARB_point_sprite (GL/glext.h:1160)
GL_POINT_SPRITE_ARB = 34913 # GL/glext.h:1161
GL_COORD_REPLACE_ARB = 34914 # GL/glext.h:1162
# ARB_fragment_program_shadow (GL/glext.h:1165)
# ARB_draw_buffers (GL/glext.h:1168)
GL_MAX_DRAW_BUFFERS_ARB = 34852 # GL/glext.h:1169
GL_DRAW_BUFFER0_ARB = 34853 # GL/glext.h:1170
GL_DRAW_BUFFER1_ARB = 34854 # GL/glext.h:1171
GL_DRAW_BUFFER2_ARB = 34855 # GL/glext.h:1172
GL_DRAW_BUFFER3_ARB = 34856 # GL/glext.h:1173
GL_DRAW_BUFFER4_ARB = 34857 # GL/glext.h:1174
GL_DRAW_BUFFER5_ARB = 34858 # GL/glext.h:1175
GL_DRAW_BUFFER6_ARB = 34859 # GL/glext.h:1176
GL_DRAW_BUFFER7_ARB = 34860 # GL/glext.h:1177
GL_DRAW_BUFFER8_ARB = 34861 # GL/glext.h:1178
GL_DRAW_BUFFER9_ARB = 34862 # GL/glext.h:1179
GL_DRAW_BUFFER10_ARB = 34863 # GL/glext.h:1180
GL_DRAW_BUFFER11_ARB = 34864 # GL/glext.h:1181
GL_DRAW_BUFFER12_ARB = 34865 # GL/glext.h:1182
GL_DRAW_BUFFER13_ARB = 34866 # GL/glext.h:1183
GL_DRAW_BUFFER14_ARB = 34867 # GL/glext.h:1184
GL_DRAW_BUFFER15_ARB = 34868 # GL/glext.h:1185
# ARB_texture_rectangle (GL/glext.h:1188)
GL_TEXTURE_RECTANGLE_ARB = 34037 # GL/glext.h:1189
GL_TEXTURE_BINDING_RECTANGLE_ARB = 34038 # GL/glext.h:1190
GL_PROXY_TEXTURE_RECTANGLE_ARB = 34039 # GL/glext.h:1191
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 34040 # GL/glext.h:1192
# ARB_color_buffer_float (GL/glext.h:1195)
GL_RGBA_FLOAT_MODE_ARB = 34848 # GL/glext.h:1196
GL_CLAMP_VERTEX_COLOR_ARB = 35098 # GL/glext.h:1197
GL_CLAMP_FRAGMENT_COLOR_ARB = 35099 # GL/glext.h:1198
GL_CLAMP_READ_COLOR_ARB = 35100 # GL/glext.h:1199
GL_FIXED_ONLY_ARB = 35101 # GL/glext.h:1200
# ARB_half_float_pixel (GL/glext.h:1203)
GL_HALF_FLOAT_ARB = 5131 # GL/glext.h:1204
# ARB_texture_float (GL/glext.h:1207)
GL_TEXTURE_RED_TYPE_ARB = 35856 # GL/glext.h:1208
GL_TEXTURE_GREEN_TYPE_ARB = 35857 # GL/glext.h:1209
GL_TEXTURE_BLUE_TYPE_ARB = 35858 # GL/glext.h:1210
GL_TEXTURE_ALPHA_TYPE_ARB = 35859 # GL/glext.h:1211
GL_TEXTURE_LUMINANCE_TYPE_ARB = 35860 # GL/glext.h:1212
GL_TEXTURE_INTENSITY_TYPE_ARB = 35861 # GL/glext.h:1213
GL_TEXTURE_DEPTH_TYPE_ARB = 35862 # GL/glext.h:1214
GL_UNSIGNED_NORMALIZED_ARB = 35863 # GL/glext.h:1215
GL_RGBA32F_ARB = 34836 # GL/glext.h:1216
GL_RGB32F_ARB = 34837 # GL/glext.h:1217
GL_ALPHA32F_ARB = 34838 # GL/glext.h:1218
GL_INTENSITY32F_ARB = 34839 # GL/glext.h:1219
GL_LUMINANCE32F_ARB = 34840 # GL/glext.h:1220
GL_LUMINANCE_ALPHA32F_ARB = 34841 # GL/glext.h:1221
GL_RGBA16F_ARB = 34842 # GL/glext.h:1222
GL_RGB16F_ARB = 34843 # GL/glext.h:1223
GL_ALPHA16F_ARB = 34844 # GL/glext.h:1224
GL_INTENSITY16F_ARB = 34845 # GL/glext.h:1225
GL_LUMINANCE16F_ARB = 34846 # GL/glext.h:1226
GL_LUMINANCE_ALPHA16F_ARB = 34847 # GL/glext.h:1227
# ARB_pixel_buffer_object (GL/glext.h:1230)
GL_PIXEL_PACK_BUFFER_ARB = 35051 # GL/glext.h:1231
GL_PIXEL_UNPACK_BUFFER_ARB = 35052 # GL/glext.h:1232
GL_PIXEL_PACK_BUFFER_BINDING_ARB = 35053 # GL/glext.h:1233
GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 35055 # GL/glext.h:1234
# ARB_depth_buffer_float (GL/glext.h:1237)
GL_DEPTH_COMPONENT32F = 36012 # GL/glext.h:1238
GL_DEPTH32F_STENCIL8 = 36013 # GL/glext.h:1239
GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 36269 # GL/glext.h:1240
# ARB_draw_instanced (GL/glext.h:1243)
# ARB_framebuffer_object (GL/glext.h:1246)
GL_INVALID_FRAMEBUFFER_OPERATION = 1286 # GL/glext.h:1247
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 33296 # GL/glext.h:1248
GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 33297 # GL/glext.h:1249
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 33298 # GL/glext.h:1250
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 33299 # GL/glext.h:1251
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 33300 # GL/glext.h:1252
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 33301 # GL/glext.h:1253
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 33302 # GL/glext.h:1254
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 33303 # GL/glext.h:1255
GL_FRAMEBUFFER_DEFAULT = 33304 # GL/glext.h:1256
GL_FRAMEBUFFER_UNDEFINED = 33305 # GL/glext.h:1257
GL_DEPTH_STENCIL_ATTACHMENT = 33306 # GL/glext.h:1258
GL_INDEX = 33314 # GL/glext.h:1259
GL_MAX_RENDERBUFFER_SIZE = 34024 # GL/glext.h:1260
GL_DEPTH_STENCIL = 34041 # GL/glext.h:1261
GL_UNSIGNED_INT_24_8 = 34042 # GL/glext.h:1262
GL_DEPTH24_STENCIL8 = 35056 # GL/glext.h:1263
GL_TEXTURE_STENCIL_SIZE = 35057 # GL/glext.h:1264
GL_FRAMEBUFFER_BINDING = 36006 # GL/glext.h:1265
GL_DRAW_FRAMEBUFFER_BINDING = 36006 # GL/glext.h:1266
GL_RENDERBUFFER_BINDING = 36007 # GL/glext.h:1267
GL_READ_FRAMEBUFFER = 36008 # GL/glext.h:1268
GL_DRAW_FRAMEBUFFER = 36009 # GL/glext.h:1269
GL_READ_FRAMEBUFFER_BINDING = 36010 # GL/glext.h:1270
GL_RENDERBUFFER_SAMPLES = 36011 # GL/glext.h:1271
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048 # GL/glext.h:1272
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049 # GL/glext.h:1273
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050 # GL/glext.h:1274
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051 # GL/glext.h:1275
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 36052 # GL/glext.h:1276
GL_FRAMEBUFFER_COMPLETE = 36053 # GL/glext.h:1277
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054 # GL/glext.h:1278
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055 # GL/glext.h:1279
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059 # GL/glext.h:1280
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060 # GL/glext.h:1281
GL_FRAMEBUFFER_UNSUPPORTED = 36061 # GL/glext.h:1282
GL_MAX_COLOR_ATTACHMENTS = 36063 # GL/glext.h:1283
GL_COLOR_ATTACHMENT0 = 36064 # GL/glext.h:1284
GL_COLOR_ATTACHMENT1 = 36065 # GL/glext.h:1285
GL_COLOR_ATTACHMENT2 = 36066 # GL/glext.h:1286
GL_COLOR_ATTACHMENT3 = 36067 # GL/glext.h:1287
GL_COLOR_ATTACHMENT4 = 36068 # GL/glext.h:1288
GL_COLOR_ATTACHMENT5 = 36069 # GL/glext.h:1289
GL_COLOR_ATTACHMENT6 = 36070 # GL/glext.h:1290
GL_COLOR_ATTACHMENT7 = 36071 # GL/glext.h:1291
GL_COLOR_ATTACHMENT8 = 36072 # GL/glext.h:1292
GL_COLOR_ATTACHMENT9 = 36073 # GL/glext.h:1293
GL_COLOR_ATTACHMENT10 = 36074 # GL/glext.h:1294
GL_COLOR_ATTACHMENT11 = 36075 # GL/glext.h:1295
GL_COLOR_ATTACHMENT12 = 36076 # GL/glext.h:1296
GL_COLOR_ATTACHMENT13 = 36077 # GL/glext.h:1297
GL_COLOR_ATTACHMENT14 = 36078 # GL/glext.h:1298
GL_COLOR_ATTACHMENT15 = 36079 # GL/glext.h:1299
GL_DEPTH_ATTACHMENT = 36096 # GL/glext.h:1300
GL_STENCIL_ATTACHMENT = 36128 # GL/glext.h:1301
GL_FRAMEBUFFER = 36160 # GL/glext.h:1302
GL_RENDERBUFFER = 36161 # GL/glext.h:1303
GL_RENDERBUFFER_WIDTH = 36162 # GL/glext.h:1304
GL_RENDERBUFFER_HEIGHT = 36163 # GL/glext.h:1305
GL_RENDERBUFFER_INTERNAL_FORMAT = 36164 # GL/glext.h:1306
GL_STENCIL_INDEX1 = 36166 # GL/glext.h:1307
GL_STENCIL_INDEX4 = 36167 # GL/glext.h:1308
GL_STENCIL_INDEX8 = 36168 # GL/glext.h:1309
GL_STENCIL_INDEX16 = 36169 # GL/glext.h:1310
GL_RENDERBUFFER_RED_SIZE = 36176 # GL/glext.h:1311
GL_RENDERBUFFER_GREEN_SIZE = 36177 # GL/glext.h:1312
GL_RENDERBUFFER_BLUE_SIZE = 36178 # GL/glext.h:1313
GL_RENDERBUFFER_ALPHA_SIZE = 36179 # GL/glext.h:1314
GL_RENDERBUFFER_DEPTH_SIZE = 36180 # GL/glext.h:1315
GL_RENDERBUFFER_STENCIL_SIZE = 36181 # GL/glext.h:1316
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 36182 # GL/glext.h:1317
GL_MAX_SAMPLES = 36183 # GL/glext.h:1318
# ARB_framebuffer_sRGB (GL/glext.h:1321)
GL_FRAMEBUFFER_SRGB = 36281 # GL/glext.h:1322
# ARB_geometry_shader4 (GL/glext.h:1325)
GL_LINES_ADJACENCY_ARB = 10 # GL/glext.h:1326
GL_LINE_STRIP_ADJACENCY_ARB = 11 # GL/glext.h:1327
GL_TRIANGLES_ADJACENCY_ARB = 12 # GL/glext.h:1328
GL_TRIANGLE_STRIP_ADJACENCY_ARB = 13 # GL/glext.h:1329
GL_PROGRAM_POINT_SIZE_ARB = 34370 # GL/glext.h:1330
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 35881 # GL/glext.h:1331
GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 36263 # GL/glext.h:1332
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 36264 # GL/glext.h:1333
GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 36265 # GL/glext.h:1334
GL_GEOMETRY_SHADER_ARB = 36313 # GL/glext.h:1335
GL_GEOMETRY_VERTICES_OUT_ARB = 36314 # GL/glext.h:1336
GL_GEOMETRY_INPUT_TYPE_ARB = 36315 # GL/glext.h:1337
GL_GEOMETRY_OUTPUT_TYPE_ARB = 36316 # GL/glext.h:1338
GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 36317 # GL/glext.h:1339
GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 36318 # GL/glext.h:1340
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 36319 # GL/glext.h:1341
GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 36320 # GL/glext.h:1342
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 36321 # GL/glext.h:1343
# ARB_half_float_vertex (GL/glext.h:1348)
GL_HALF_FLOAT = 5131 # GL/glext.h:1349
# ARB_instanced_arrays (GL/glext.h:1352)
# ARB_map_buffer_range (GL/glext.h:1355)
GL_MAP_READ_BIT = 1 # GL/glext.h:1356
GL_MAP_WRITE_BIT = 2 # GL/glext.h:1357
GL_MAP_INVALIDATE_RANGE_BIT = 4 # GL/glext.h:1358
GL_MAP_INVALIDATE_BUFFER_BIT = 8 # GL/glext.h:1359
GL_MAP_FLUSH_EXPLICIT_BIT = 16 # GL/glext.h:1360
GL_MAP_UNSYNCHRONIZED_BIT = 32 # GL/glext.h:1361
# ARB_texture_buffer_object (GL/glext.h:1364)
GL_TEXTURE_BUFFER_ARB = 35882 # GL/glext.h:1365
GL_MAX_TEXTURE_BUFFER_SIZE_ARB = 35883 # GL/glext.h:1366
GL_TEXTURE_BINDING_BUFFER_ARB = 35884 # GL/glext.h:1367
GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 35885 # GL/glext.h:1368
GL_TEXTURE_BUFFER_FORMAT_ARB = 35886 # GL/glext.h:1369
# ARB_texture_compression_rgtc (GL/glext.h:1372)
GL_COMPRESSED_RED_RGTC1 = 36283 # GL/glext.h:1373
GL_COMPRESSED_SIGNED_RED_RGTC1 = 36284 # GL/glext.h:1374
GL_COMPRESSED_RG_RGTC2 = 36285 # GL/glext.h:1375
GL_COMPRESSED_SIGNED_RG_RGTC2 = 36286 # GL/glext.h:1376
# ARB_texture_rg (GL/glext.h:1379)
GL_RG = 33319 # GL/glext.h:1380
GL_RG_INTEGER = 33320 # GL/glext.h:1381
GL_R8 = 33321 # GL/glext.h:1382
GL_R16 = 33322 # GL/glext.h:1383
GL_RG8 = 33323 # GL/glext.h:1384
GL_RG16 = 33324 # GL/glext.h:1385
GL_R16F = 33325 # GL/glext.h:1386
GL_R32F = 33326 # GL/glext.h:1387
GL_RG16F = 33327 # GL/glext.h:1388
GL_RG32F = 33328 # GL/glext.h:1389
GL_R8I = 33329 # GL/glext.h:1390
GL_R8UI = 33330 # GL/glext.h:1391
GL_R16I = 33331 # GL/glext.h:1392
GL_R16UI = 33332 # GL/glext.h:1393
GL_R32I = 33333 # GL/glext.h:1394
GL_R32UI = 33334 # GL/glext.h:1395
GL_RG8I = 33335 # GL/glext.h:1396
GL_RG8UI = 33336 # GL/glext.h:1397
GL_RG16I = 33337 # GL/glext.h:1398
GL_RG16UI = 33338 # GL/glext.h:1399
GL_RG32I = 33339 # GL/glext.h:1400
GL_RG32UI = 33340 # GL/glext.h:1401
# ARB_vertex_array_object (GL/glext.h:1404)
GL_VERTEX_ARRAY_BINDING = 34229 # GL/glext.h:1405
# EXT_abgr (GL/glext.h:1408)
GL_ABGR_EXT = 32768 # GL/glext.h:1409
# EXT_blend_color (GL/glext.h:1412)
GL_CONSTANT_COLOR_EXT = 32769 # GL/glext.h:1413
GL_ONE_MINUS_CONSTANT_COLOR_EXT = 32770 # GL/glext.h:1414
GL_CONSTANT_ALPHA_EXT = 32771 # GL/glext.h:1415
GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 32772 # GL/glext.h:1416
GL_BLEND_COLOR_EXT = 32773 # GL/glext.h:1417
# EXT_polygon_offset (GL/glext.h:1420)
GL_POLYGON_OFFSET_EXT = 32823 # GL/glext.h:1421
GL_POLYGON_OFFSET_FACTOR_EXT = 32824 # GL/glext.h:1422
GL_POLYGON_OFFSET_BIAS_EXT = 32825 # GL/glext.h:1423
# EXT_texture (GL/glext.h:1426)
GL_ALPHA4_EXT = 32827 # GL/glext.h:1427
GL_ALPHA8_EXT = 32828 # GL/glext.h:1428
GL_ALPHA12_EXT = 32829 # GL/glext.h:1429
GL_ALPHA16_EXT = 32830 # GL/glext.h:1430
GL_LUMINANCE4_EXT = 32831 # GL/glext.h:1431
GL_LUMINANCE8_EXT = 32832 # GL/glext.h:1432
GL_LUMINANCE12_EXT = 32833 # GL/glext.h:1433
GL_LUMINANCE16_EXT = 32834 # GL/glext.h:1434
GL_LUMINANCE4_ALPHA4_EXT = 32835 # GL/glext.h:1435
GL_LUMINANCE6_ALPHA2_EXT = 32836 # GL/glext.h:1436
GL_LUMINANCE8_ALPHA8_EXT = 32837 # GL/glext.h:1437
GL_LUMINANCE12_ALPHA4_EXT = 32838 # GL/glext.h:1438
GL_LUMINANCE12_ALPHA12_EXT = 32839 # GL/glext.h:1439
GL_LUMINANCE16_ALPHA16_EXT = 32840 # GL/glext.h:1440
GL_INTENSITY_EXT = 32841 # GL/glext.h:1441
GL_INTENSITY4_EXT = 32842 # GL/glext.h:1442
GL_INTENSITY8_EXT = 32843 # GL/glext.h:1443
GL_INTENSITY12_EXT = 32844 # GL/glext.h:1444
GL_INTENSITY16_EXT = 32845 # GL/glext.h:1445
GL_RGB2_EXT = 32846 # GL/glext.h:1446
GL_RGB4_EXT = 32847 # GL/glext.h:1447
GL_RGB5_EXT = 32848 # GL/glext.h:1448
GL_RGB8_EXT = 32849 # GL/glext.h:1449
GL_RGB10_EXT = 32850 # GL/glext.h:1450
GL_RGB12_EXT = 32851 # GL/glext.h:1451
GL_RGB16_EXT = 32852 # GL/glext.h:1452
GL_RGBA2_EXT = 32853 # GL/glext.h:1453
GL_RGBA4_EXT = 32854 # GL/glext.h:1454
GL_RGB5_A1_EXT = 32855 # GL/glext.h:1455
GL_RGBA8_EXT = 32856 # GL/glext.h:1456
GL_RGB10_A2_EXT = 32857 # GL/glext.h:1457
GL_RGBA12_EXT = 32858 # GL/glext.h:1458
GL_RGBA16_EXT = 32859 # GL/glext.h:1459
GL_TEXTURE_RED_SIZE_EXT = 32860 # GL/glext.h:1460
GL_TEXTURE_GREEN_SIZE_EXT = 32861 # GL/glext.h:1461
GL_TEXTURE_BLUE_SIZE_EXT = 32862 # GL/glext.h:1462
GL_TEXTURE_ALPHA_SIZE_EXT = 32863 # GL/glext.h:1463
GL_TEXTURE_LUMINANCE_SIZE_EXT = 32864 # GL/glext.h:1464
GL_TEXTURE_INTENSITY_SIZE_EXT = 32865 # GL/glext.h:1465
GL_REPLACE_EXT = 32866 # GL/glext.h:1466
GL_PROXY_TEXTURE_1D_EXT = 32867 # GL/glext.h:1467
GL_PROXY_TEXTURE_2D_EXT = 32868 # GL/glext.h:1468
GL_TEXTURE_TOO_LARGE_EXT = 32869 # GL/glext.h:1469
# EXT_texture3D (GL/glext.h:1472)
GL_PACK_SKIP_IMAGES_EXT = 32875 # GL/glext.h:1473
GL_PACK_IMAGE_HEIGHT_EXT = 32876 # GL/glext.h:1474
GL_UNPACK_SKIP_IMAGES_EXT = 32877 # GL/glext.h:1475
GL_UNPACK_IMAGE_HEIGHT_EXT = 32878 # GL/glext.h:1476
GL_TEXTURE_3D_EXT = 32879 # GL/glext.h:1477
GL_PROXY_TEXTURE_3D_EXT = 32880 # GL/glext.h:1478
GL_TEXTURE_DEPTH_EXT = 32881 # GL/glext.h:1479
GL_TEXTURE_WRAP_R_EXT = 32882 # GL/glext.h:1480
GL_MAX_3D_TEXTURE_SIZE_EXT = 32883 # GL/glext.h:1481
# SGIS_texture_filter4 (GL/glext.h:1484)
GL_FILTER4_SGIS = 33094 # GL/glext.h:1485
GL_TEXTURE_FILTER4_SIZE_SGIS = 33095 # GL/glext.h:1486
# EXT_subtexture (GL/glext.h:1489)
# EXT_copy_texture (GL/glext.h:1492)
# EXT_histogram (GL/glext.h:1495)
GL_HISTOGRAM_EXT = 32804 # GL/glext.h:1496
GL_PROXY_HISTOGRAM_EXT = 32805 # GL/glext.h:1497
GL_HISTOGRAM_WIDTH_EXT = 32806 # GL/glext.h:1498
GL_HISTOGRAM_FORMAT_EXT = 32807 # GL/glext.h:1499
GL_HISTOGRAM_RED_SIZE_EXT = 32808 # GL/glext.h:1500
GL_HISTOGRAM_GREEN_SIZE_EXT = 32809 # GL/glext.h:1501
GL_HISTOGRAM_BLUE_SIZE_EXT = 32810 # GL/glext.h:1502
GL_HISTOGRAM_ALPHA_SIZE_EXT = 32811 # GL/glext.h:1503
GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 32812 # GL/glext.h:1504
GL_HISTOGRAM_SINK_EXT = 32813 # GL/glext.h:1505
GL_MINMAX_EXT = 32814 # GL/glext.h:1506
GL_MINMAX_FORMAT_EXT = 32815 # GL/glext.h:1507
GL_MINMAX_SINK_EXT = 32816 # GL/glext.h:1508
GL_TABLE_TOO_LARGE_EXT = 32817 # GL/glext.h:1509
# EXT_convolution (GL/glext.h:1512)
GL_CONVOLUTION_1D_EXT = 32784 # GL/glext.h:1513
GL_CONVOLUTION_2D_EXT = 32785 # GL/glext.h:1514
GL_SEPARABLE_2D_EXT = 32786 # GL/glext.h:1515
GL_CONVOLUTION_BORDER_MODE_EXT = 32787 # GL/glext.h:1516
GL_CONVOLUTION_FILTER_SCALE_EXT = 32788 # GL/glext.h:1517
GL_CONVOLUTION_FILTER_BIAS_EXT = 32789 # GL/glext.h:1518
GL_REDUCE_EXT = 32790 # GL/glext.h:1519
GL_CONVOLUTION_FORMAT_EXT = 32791 # GL/glext.h:1520
GL_CONVOLUTION_WIDTH_EXT = 32792 # GL/glext.h:1521
GL_CONVOLUTION_HEIGHT_EXT = 32793 # GL/glext.h:1522
GL_MAX_CONVOLUTION_WIDTH_EXT = 32794 # GL/glext.h:1523
GL_MAX_CONVOLUTION_HEIGHT_EXT = 32795 # GL/glext.h:1524
GL_POST_CONVOLUTION_RED_SCALE_EXT = 32796 # GL/glext.h:1525
GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 32797 # GL/glext.h:1526
GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 32798 # GL/glext.h:1527
GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 32799 # GL/glext.h:1528
GL_POST_CONVOLUTION_RED_BIAS_EXT = 32800 # GL/glext.h:1529
GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 32801 # GL/glext.h:1530
GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 32802 # GL/glext.h:1531
GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 32803 # GL/glext.h:1532
# SGI_color_matrix (GL/glext.h:1535)
GL_COLOR_MATRIX_SGI = 32945 # GL/glext.h:1536
GL_COLOR_MATRIX_STACK_DEPTH_SGI = 32946 # GL/glext.h:1537
GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 32947 # GL/glext.h:1538
GL_POST_COLOR_MATRIX_RED_SCALE_SGI = 32948 # GL/glext.h:1539
GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 32949 # GL/glext.h:1540
GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 32950 # GL/glext.h:1541
GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 32951 # GL/glext.h:1542
GL_POST_COLOR_MATRIX_RED_BIAS_SGI = 32952 # GL/glext.h:1543
GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 32953 # GL/glext.h:1544
GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 32954 # GL/glext.h:1545
GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 32955 # GL/glext.h:1546
# SGI_color_table (GL/glext.h:1549)
GL_COLOR_TABLE_SGI = 32976 # GL/glext.h:1550
GL_POST_CONVOLUTION_COLOR_TABLE_SGI = 32977 # GL/glext.h:1551
GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 32978 # GL/glext.h:1552
GL_PROXY_COLOR_TABLE_SGI = 32979 # GL/glext.h:1553
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 32980 # GL/glext.h:1554
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 32981 # GL/glext.h:1555
GL_COLOR_TABLE_SCALE_SGI = 32982 # GL/glext.h:1556
GL_COLOR_TABLE_BIAS_SGI = 32983 # GL/glext.h:1557
GL_COLOR_TABLE_FORMAT_SGI = 32984 # GL/glext.h:1558
GL_COLOR_TABLE_WIDTH_SGI = 32985 # GL/glext.h:1559
GL_COLOR_TABLE_RED_SIZE_SGI = 32986 # GL/glext.h:1560
GL_COLOR_TABLE_GREEN_SIZE_SGI = 32987 # GL/glext.h:1561
GL_COLOR_TABLE_BLUE_SIZE_SGI = 32988 # GL/glext.h:1562
GL_COLOR_TABLE_ALPHA_SIZE_SGI = 32989 # GL/glext.h:1563
GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = 32990 # GL/glext.h:1564
GL_COLOR_TABLE_INTENSITY_SIZE_SGI = 32991 # GL/glext.h:1565
# SGIS_pixel_texture (GL/glext.h:1568)
GL_PIXEL_TEXTURE_SGIS = 33619 # GL/glext.h:1569
GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 33620 # GL/glext.h:1570
GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 33621 # GL/glext.h:1571
GL_PIXEL_GROUP_COLOR_SGIS = 33622 # GL/glext.h:1572
# SGIX_pixel_texture (GL/glext.h:1575)
GL_PIXEL_TEX_GEN_SGIX = 33081 # GL/glext.h:1576
GL_PIXEL_TEX_GEN_MODE_SGIX = 33579 # GL/glext.h:1577
# SGIS_texture4D (GL/glext.h:1580)
GL_PACK_SKIP_VOLUMES_SGIS = 33072 # GL/glext.h:1581
GL_PACK_IMAGE_DEPTH_SGIS = 33073 # GL/glext.h:1582
GL_UNPACK_SKIP_VOLUMES_SGIS = 33074 # GL/glext.h:1583
GL_UNPACK_IMAGE_DEPTH_SGIS = 33075 # GL/glext.h:1584
GL_TEXTURE_4D_SGIS = 33076 # GL/glext.h:1585
GL_PROXY_TEXTURE_4D_SGIS = 33077 # GL/glext.h:1586
GL_TEXTURE_4DSIZE_SGIS = 33078 # GL/glext.h:1587
GL_TEXTURE_WRAP_Q_SGIS = 33079 # GL/glext.h:1588
GL_MAX_4D_TEXTURE_SIZE_SGIS = 33080 # GL/glext.h:1589
GL_TEXTURE_4D_BINDING_SGIS = 33103 # GL/glext.h:1590
# SGI_texture_color_table (GL/glext.h:1593)
GL_TEXTURE_COLOR_TABLE_SGI = 32956 # GL/glext.h:1594
GL_PROXY_TEXTURE_COLOR_TABLE_SGI = 32957 # GL/glext.h:1595
# EXT_cmyka (GL/glext.h:1598)
GL_CMYK_EXT = 32780 # GL/glext.h:1599
GL_CMYKA_EXT = 32781 # GL/glext.h:1600
GL_PACK_CMYK_HINT_EXT = 32782 # GL/glext.h:1601
GL_UNPACK_CMYK_HINT_EXT = 32783 # GL/glext.h:1602
# EXT_texture_object (GL/glext.h:1605)
GL_TEXTURE_PRIORITY_EXT = 32870 # GL/glext.h:1606
GL_TEXTURE_RESIDENT_EXT = 32871 # GL/glext.h:1607
GL_TEXTURE_1D_BINDING_EXT = 32872 # GL/glext.h:1608
GL_TEXTURE_2D_BINDING_EXT = 32873 # GL/glext.h:1609
GL_TEXTURE_3D_BINDING_EXT = 32874 # GL/glext.h:1610
# SGIS_detail_texture (GL/glext.h:1613)
GL_DETAIL_TEXTURE_2D_SGIS = 32917 # GL/glext.h:1614
GL_DETAIL_TEXTURE_2D_BINDING_SGIS = 32918 # GL/glext.h:1615
GL_LINEAR_DETAIL_SGIS = 32919 # GL/glext.h:1616
GL_LINEAR_DETAIL_ALPHA_SGIS = 32920 # GL/glext.h:1617
GL_LINEAR_DETAIL_COLOR_SGIS = 32921 # GL/glext.h:1618
GL_DETAIL_TEXTURE_LEVEL_SGIS = 32922 # GL/glext.h:1619
GL_DETAIL_TEXTURE_MODE_SGIS = 32923 # GL/glext.h:1620
GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 32924 # GL/glext.h:1621
# SGIS_sharpen_texture (GL/glext.h:1624)
GL_LINEAR_SHARPEN_SGIS = 32941 # GL/glext.h:1625
GL_LINEAR_SHARPEN_ALPHA_SGIS = 32942 # GL/glext.h:1626
GL_LINEAR_SHARPEN_COLOR_SGIS = 32943 # GL/glext.h:1627
GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 32944 # GL/glext.h:1628
# EXT_packed_pixels (GL/glext.h:1631)
GL_UNSIGNED_BYTE_3_3_2_EXT = 32818 # GL/glext.h:1632
GL_UNSIGNED_SHORT_4_4_4_4_EXT = 32819 # GL/glext.h:1633
GL_UNSIGNED_SHORT_5_5_5_1_EXT = 32820 # GL/glext.h:1634
GL_UNSIGNED_INT_8_8_8_8_EXT = 32821 # GL/glext.h:1635
GL_UNSIGNED_INT_10_10_10_2_EXT = 32822 # GL/glext.h:1636
# SGIS_texture_lod (GL/glext.h:1639)
GL_TEXTURE_MIN_LOD_SGIS = 33082 # GL/glext.h:1640
GL_TEXTURE_MAX_LOD_SGIS = 33083 # GL/glext.h:1641
GL_TEXTURE_BASE_LEVEL_SGIS = 33084 # GL/glext.h:1642
GL_TEXTURE_MAX_LEVEL_SGIS = 33085 # GL/glext.h:1643
# SGIS_multisample (GL/glext.h:1646)
GL_MULTISAMPLE_SGIS = 32925 # GL/glext.h:1647
GL_SAMPLE_ALPHA_TO_MASK_SGIS = 32926 # GL/glext.h:1648
GL_SAMPLE_ALPHA_TO_ONE_SGIS = 32927 # GL/glext.h:1649
GL_SAMPLE_MASK_SGIS = 32928 # GL/glext.h:1650
GL_1PASS_SGIS = 32929 # GL/glext.h:1651
GL_2PASS_0_SGIS = 32930 # GL/glext.h:1652
GL_2PASS_1_SGIS = 32931 # GL/glext.h:1653
GL_4PASS_0_SGIS = 32932 # GL/glext.h:1654
GL_4PASS_1_SGIS = 32933 # GL/glext.h:1655
GL_4PASS_2_SGIS = 32934 # GL/glext.h:1656
GL_4PASS_3_SGIS = 32935 # GL/glext.h:1657
GL_SAMPLE_BUFFERS_SGIS = 32936 # GL/glext.h:1658
GL_SAMPLES_SGIS = 32937 # GL/glext.h:1659
GL_SAMPLE_MASK_VALUE_SGIS = 32938 # GL/glext.h:1660
GL_SAMPLE_MASK_INVERT_SGIS = 32939 # GL/glext.h:1661
GL_SAMPLE_PATTERN_SGIS = 32940 # GL/glext.h:1662
# EXT_rescale_normal (GL/glext.h:1665)
GL_RESCALE_NORMAL_EXT = 32826 # GL/glext.h:1666
# EXT_vertex_array (GL/glext.h:1669)
GL_VERTEX_ARRAY_EXT = 32884 # GL/glext.h:1670
GL_NORMAL_ARRAY_EXT = 32885 # GL/glext.h:1671
GL_COLOR_ARRAY_EXT = 32886 # GL/glext.h:1672
GL_INDEX_ARRAY_EXT = 32887 # GL/glext.h:1673
GL_TEXTURE_COORD_ARRAY_EXT = 32888 # GL/glext.h:1674
GL_EDGE_FLAG_ARRAY_EXT = 32889 # GL/glext.h:1675
GL_VERTEX_ARRAY_SIZE_EXT = 32890 # GL/glext.h:1676
GL_VERTEX_ARRAY_TYPE_EXT = 32891 # GL/glext.h:1677
GL_VERTEX_ARRAY_STRIDE_EXT = 32892 # GL/glext.h:1678
GL_VERTEX_ARRAY_COUNT_EXT = 32893 # GL/glext.h:1679
GL_NORMAL_ARRAY_TYPE_EXT = 32894 # GL/glext.h:1680
GL_NORMAL_ARRAY_STRIDE_EXT = 32895 # GL/glext.h:1681
GL_NORMAL_ARRAY_COUNT_EXT = 32896 # GL/glext.h:1682
GL_COLOR_ARRAY_SIZE_EXT = 32897 # GL/glext.h:1683
GL_COLOR_ARRAY_TYPE_EXT = 32898 # GL/glext.h:1684
GL_COLOR_ARRAY_STRIDE_EXT = 32899 # GL/glext.h:1685
GL_COLOR_ARRAY_COUNT_EXT = 32900 # GL/glext.h:1686
GL_INDEX_ARRAY_TYPE_EXT = 32901 # GL/glext.h:1687
GL_INDEX_ARRAY_STRIDE_EXT = 32902 # GL/glext.h:1688
GL_INDEX_ARRAY_COUNT_EXT = 32903 # GL/glext.h:1689
GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 32904 # GL/glext.h:1690
GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 32905 # GL/glext.h:1691
GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 32906 # GL/glext.h:1692
GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 32907 # GL/glext.h:1693
GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 32908 # GL/glext.h:1694
GL_EDGE_FLAG_ARRAY_COUNT_EXT = 32909 # GL/glext.h:1695
GL_VERTEX_ARRAY_POINTER_EXT = 32910 # GL/glext.h:1696
GL_NORMAL_ARRAY_POINTER_EXT = 32911 # GL/glext.h:1697
GL_COLOR_ARRAY_POINTER_EXT = 32912 # GL/glext.h:1698
GL_INDEX_ARRAY_POINTER_EXT = 32913 # GL/glext.h:1699
GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 32914 # GL/glext.h:1700
GL_EDGE_FLAG_ARRAY_POINTER_EXT = 32915 # GL/glext.h:1701
# EXT_misc_attribute (GL/glext.h:1704)
# SGIS_generate_mipmap (GL/glext.h:1707)
GL_GENERATE_MIPMAP_SGIS = 33169 # GL/glext.h:1708
GL_GENERATE_MIPMAP_HINT_SGIS = 33170 # GL/glext.h:1709
# SGIX_clipmap (GL/glext.h:1712)
GL_LINEAR_CLIPMAP_LINEAR_SGIX = 33136 # GL/glext.h:1713
GL_TEXTURE_CLIPMAP_CENTER_SGIX = 33137 # GL/glext.h:1714
GL_TEXTURE_CLIPMAP_FRAME_SGIX = 33138 # GL/glext.h:1715
GL_TEXTURE_CLIPMAP_OFFSET_SGIX = 33139 # GL/glext.h:1716
GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 33140 # GL/glext.h:1717
GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 33141 # GL/glext.h:1718
GL_TEXTURE_CLIPMAP_DEPTH_SGIX = 33142 # GL/glext.h:1719
GL_MAX_CLIPMAP_DEPTH_SGIX = 33143 # GL/glext.h:1720
GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 33144 # GL/glext.h:1721
GL_NEAREST_CLIPMAP_NEAREST_SGIX = 33869 # GL/glext.h:1722
GL_NEAREST_CLIPMAP_LINEAR_SGIX = 33870 # GL/glext.h:1723
GL_LINEAR_CLIPMAP_NEAREST_SGIX = 33871 # GL/glext.h:1724
# SGIX_shadow (GL/glext.h:1727)
GL_TEXTURE_COMPARE_SGIX = 33178 # GL/glext.h:1728
GL_TEXTURE_COMPARE_OPERATOR_SGIX = 33179 # GL/glext.h:1729
GL_TEXTURE_LEQUAL_R_SGIX = 33180 # GL/glext.h:1730
GL_TEXTURE_GEQUAL_R_SGIX = 33181 # GL/glext.h:1731
# SGIS_texture_edge_clamp (GL/glext.h:1734)
GL_CLAMP_TO_EDGE_SGIS = 33071 # GL/glext.h:1735
# SGIS_texture_border_clamp (GL/glext.h:1738)
GL_CLAMP_TO_BORDER_SGIS = 33069 # GL/glext.h:1739
# EXT_blend_minmax (GL/glext.h:1742)
GL_FUNC_ADD_EXT = 32774 # GL/glext.h:1743
GL_MIN_EXT = 32775 # GL/glext.h:1744
GL_MAX_EXT = 32776 # GL/glext.h:1745
GL_BLEND_EQUATION_EXT = 32777 # GL/glext.h:1746
# EXT_blend_subtract (GL/glext.h:1749)
GL_FUNC_SUBTRACT_EXT = 32778 # GL/glext.h:1750
GL_FUNC_REVERSE_SUBTRACT_EXT = 32779 # GL/glext.h:1751
# EXT_blend_logic_op (GL/glext.h:1754)
# SGIX_interlace (GL/glext.h:1757)
GL_INTERLACE_SGIX = 32916 # GL/glext.h:1758
# SGIX_pixel_tiles (GL/glext.h:1761)
GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 33086 # GL/glext.h:1762
GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = 33087 # GL/glext.h:1763
GL_PIXEL_TILE_WIDTH_SGIX = 33088 # GL/glext.h:1764
GL_PIXEL_TILE_HEIGHT_SGIX = 33089 # GL/glext.h:1765
GL_PIXEL_TILE_GRID_WIDTH_SGIX = 33090 # GL/glext.h:1766
GL_PIXEL_TILE_GRID_HEIGHT_SGIX = 33091 # GL/glext.h:1767
GL_PIXEL_TILE_GRID_DEPTH_SGIX = 33092 # GL/glext.h:1768
GL_PIXEL_TILE_CACHE_SIZE_SGIX = 33093 # GL/glext.h:1769
# SGIS_texture_select (GL/glext.h:1772)
GL_DUAL_ALPHA4_SGIS = 33040 # GL/glext.h:1773
GL_DUAL_ALPHA8_SGIS = 33041 # GL/glext.h:1774
GL_DUAL_ALPHA12_SGIS = 33042 # GL/glext.h:1775
GL_DUAL_ALPHA16_SGIS = 33043 # GL/glext.h:1776
GL_DUAL_LUMINANCE4_SGIS = 33044 # GL/glext.h:1777
GL_DUAL_LUMINANCE8_SGIS = 33045 # GL/glext.h:1778
GL_DUAL_LUMINANCE12_SGIS = 33046 # GL/glext.h:1779
GL_DUAL_LUMINANCE16_SGIS = 33047 # GL/glext.h:1780
GL_DUAL_INTENSITY4_SGIS = 33048 # GL/glext.h:1781
GL_DUAL_INTENSITY8_SGIS = 33049 # GL/glext.h:1782
GL_DUAL_INTENSITY12_SGIS = 33050 # GL/glext.h:1783
GL_DUAL_INTENSITY16_SGIS = 33051 # GL/glext.h:1784
GL_DUAL_LUMINANCE_ALPHA4_SGIS = 33052 # GL/glext.h:1785
GL_DUAL_LUMINANCE_ALPHA8_SGIS = 33053 # GL/glext.h:1786
GL_QUAD_ALPHA4_SGIS = 33054 # GL/glext.h:1787
GL_QUAD_ALPHA8_SGIS = 33055 # GL/glext.h:1788
GL_QUAD_LUMINANCE4_SGIS = 33056 # GL/glext.h:1789
GL_QUAD_LUMINANCE8_SGIS = 33057 # GL/glext.h:1790
GL_QUAD_INTENSITY4_SGIS = 33058 # GL/glext.h:1791
GL_QUAD_INTENSITY8_SGIS = 33059 # GL/glext.h:1792
GL_DUAL_TEXTURE_SELECT_SGIS = 33060 # GL/glext.h:1793
GL_QUAD_TEXTURE_SELECT_SGIS = 33061 # GL/glext.h:1794
# SGIX_sprite (GL/glext.h:1797)
GL_SPRITE_SGIX = 33096 # GL/glext.h:1798
GL_SPRITE_MODE_SGIX = 33097 # GL/glext.h:1799
GL_SPRITE_AXIS_SGIX = 33098 # GL/glext.h:1800
GL_SPRITE_TRANSLATION_SGIX = 33099 # GL/glext.h:1801
GL_SPRITE_AXIAL_SGIX = 33100 # GL/glext.h:1802
GL_SPRITE_OBJECT_ALIGNED_SGIX = 33101 # GL/glext.h:1803
GL_SPRITE_EYE_ALIGNED_SGIX = 33102 # GL/glext.h:1804
# SGIX_texture_multi_buffer (GL/glext.h:1807)
GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = 33070 # GL/glext.h:1808
# EXT_point_parameters (GL/glext.h:1811)
GL_POINT_SIZE_MIN_EXT = 33062 # GL/glext.h:1812
GL_POINT_SIZE_MAX_EXT = 33063 # GL/glext.h:1813
GL_POINT_FADE_THRESHOLD_SIZE_EXT = 33064 # GL/glext.h:1814
GL_DISTANCE_ATTENUATION_EXT = 33065 # GL/glext.h:1815
# SGIS_point_parameters (GL/glext.h:1818)
GL_POINT_SIZE_MIN_SGIS = 33062 # GL/glext.h:1819
GL_POINT_SIZE_MAX_SGIS = 33063 # GL/glext.h:1820
GL_POINT_FADE_THRESHOLD_SIZE_SGIS = 33064 # GL/glext.h:1821
GL_DISTANCE_ATTENUATION_SGIS = 33065 # GL/glext.h:1822
# SGIX_instruments (GL/glext.h:1825)
GL_INSTRUMENT_BUFFER_POINTER_SGIX = 33152 # GL/glext.h:1826
GL_INSTRUMENT_MEASUREMENTS_SGIX = 33153 # GL/glext.h:1827
# SGIX_texture_scale_bias (GL/glext.h:1830)
GL_POST_TEXTURE_FILTER_BIAS_SGIX = 33145 # GL/glext.h:1831
GL_POST_TEXTURE_FILTER_SCALE_SGIX = 33146 # GL/glext.h:1832
GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 33147 # GL/glext.h:1833
GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 33148 # GL/glext.h:1834
# SGIX_framezoom (GL/glext.h:1837)
GL_FRAMEZOOM_SGIX = 33163 # GL/glext.h:1838
GL_FRAMEZOOM_FACTOR_SGIX = 33164 # GL/glext.h:1839
GL_MAX_FRAMEZOOM_FACTOR_SGIX = 33165 # GL/glext.h:1840
# SGIX_tag_sample_buffer (GL/glext.h:1843)
# FfdMaskSGIX (GL/glext.h:1846)
GL_TEXTURE_DEFORMATION_BIT_SGIX = 1 # GL/glext.h:1847
GL_GEOMETRY_DEFORMATION_BIT_SGIX = 2 # GL/glext.h:1848
# SGIX_polynomial_ffd (GL/glext.h:1851)
GL_GEOMETRY_DEFORMATION_SGIX = 33172 # GL/glext.h:1852
GL_TEXTURE_DEFORMATION_SGIX = 33173 # GL/glext.h:1853
GL_DEFORMATIONS_MASK_SGIX = 33174 # GL/glext.h:1854
GL_MAX_DEFORMATION_ORDER_SGIX = 33175 # GL/glext.h:1855
# SGIX_reference_plane (GL/glext.h:1858)
GL_REFERENCE_PLANE_SGIX = 33149 # GL/glext.h:1859
GL_REFERENCE_PLANE_EQUATION_SGIX = 33150 # GL/glext.h:1860
# SGIX_flush_raster (GL/glext.h:1863)
# SGIX_depth_texture (GL/glext.h:1866)
GL_DEPTH_COMPONENT16_SGIX = 33189 # GL/glext.h:1867
GL_DEPTH_COMPONENT24_SGIX = 33190 # GL/glext.h:1868
GL_DEPTH_COMPONENT32_SGIX = 33191 # GL/glext.h:1869
# SGIS_fog_function (GL/glext.h:1872)
GL_FOG_FUNC_SGIS = 33066 # GL/glext.h:1873
GL_FOG_FUNC_POINTS_SGIS = 33067 # GL/glext.h:1874
GL_MAX_FOG_FUNC_POINTS_SGIS = 33068 # GL/glext.h:1875
# SGIX_fog_offset (GL/glext.h:1878)
GL_FOG_OFFSET_SGIX = 33176 # GL/glext.h:1879
GL_FOG_OFFSET_VALUE_SGIX = 33177 # GL/glext.h:1880
# HP_image_transform (GL/glext.h:1883)
GL_IMAGE_SCALE_X_HP = 33109 # GL/glext.h:1884
GL_IMAGE_SCALE_Y_HP = 33110 # GL/glext.h:1885
GL_IMAGE_TRANSLATE_X_HP = 33111 # GL/glext.h:1886
GL_IMAGE_TRANSLATE_Y_HP = 33112 # GL/glext.h:1887
GL_IMAGE_ROTATE_ANGLE_HP = 33113 # GL/glext.h:1888
GL_IMAGE_ROTATE_ORIGIN_X_HP = 33114 # GL/glext.h:1889
GL_IMAGE_ROTATE_ORIGIN_Y_HP = 33115 # GL/glext.h:1890
GL_IMAGE_MAG_FILTER_HP = 33116 # GL/glext.h:1891
GL_IMAGE_MIN_FILTER_HP = 33117 # GL/glext.h:1892
GL_IMAGE_CUBIC_WEIGHT_HP = 33118 # GL/glext.h:1893
GL_CUBIC_HP = 33119 # GL/glext.h:1894
GL_AVERAGE_HP = 33120 # GL/glext.h:1895
GL_IMAGE_TRANSFORM_2D_HP = 33121 # GL/glext.h:1896
GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 33122 # GL/glext.h:1897
GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 33123 # GL/glext.h:1898
# HP_convolution_border_modes (GL/glext.h:1901)
GL_IGNORE_BORDER_HP = 33104 # GL/glext.h:1902
GL_CONSTANT_BORDER_HP = 33105 # GL/glext.h:1903
GL_REPLICATE_BORDER_HP = 33107 # GL/glext.h:1904
GL_CONVOLUTION_BORDER_COLOR_HP = 33108 # GL/glext.h:1905
# INGR_palette_buffer (GL/glext.h:1908)
# SGIX_texture_add_env (GL/glext.h:1911)
GL_TEXTURE_ENV_BIAS_SGIX = 32958 # GL/glext.h:1912
# EXT_color_subtable (GL/glext.h:1915)
# PGI_vertex_hints (GL/glext.h:1918)
GL_VERTEX_DATA_HINT_PGI = 107050 # GL/glext.h:1919
GL_VERTEX_CONSISTENT_HINT_PGI = 107051 # GL/glext.h:1920
GL_MATERIAL_SIDE_HINT_PGI = 107052 # GL/glext.h:1921
GL_MAX_VERTEX_HINT_PGI = 107053 # GL/glext.h:1922
GL_COLOR3_BIT_PGI = 65536 # GL/glext.h:1923
GL_COLOR4_BIT_PGI = 131072 # GL/glext.h:1924
GL_EDGEFLAG_BIT_PGI = 262144 # GL/glext.h:1925
GL_INDEX_BIT_PGI = 524288 # GL/glext.h:1926
GL_MAT_AMBIENT_BIT_PGI = 1048576 # GL/glext.h:1927
GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 2097152 # GL/glext.h:1928
GL_MAT_DIFFUSE_BIT_PGI = 4194304 # GL/glext.h:1929
GL_MAT_EMISSION_BIT_PGI = 8388608 # GL/glext.h:1930
GL_MAT_COLOR_INDEXES_BIT_PGI = 16777216 # GL/glext.h:1931
GL_MAT_SHININESS_BIT_PGI = 33554432 # GL/glext.h:1932
GL_MAT_SPECULAR_BIT_PGI = 67108864 # GL/glext.h:1933
GL_NORMAL_BIT_PGI = 134217728 # GL/glext.h:1934
GL_TEXCOORD1_BIT_PGI = 268435456 # GL/glext.h:1935
GL_TEXCOORD2_BIT_PGI = 536870912 # GL/glext.h:1936
GL_TEXCOORD3_BIT_PGI = 1073741824 # GL/glext.h:1937
GL_TEXCOORD4_BIT_PGI = 2147483648 # GL/glext.h:1938
GL_VERTEX23_BIT_PGI = 4 # GL/glext.h:1939
GL_VERTEX4_BIT_PGI = 8 # GL/glext.h:1940
# PGI_misc_hints (GL/glext.h:1943)
GL_PREFER_DOUBLEBUFFER_HINT_PGI = 107000 # GL/glext.h:1944
GL_CONSERVE_MEMORY_HINT_PGI = 107005 # GL/glext.h:1945
GL_RECLAIM_MEMORY_HINT_PGI = 107006 # GL/glext.h:1946
GL_NATIVE_GRAPHICS_HANDLE_PGI = 107010 # GL/glext.h:1947
GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 107011 # GL/glext.h:1948
GL_NATIVE_GRAPHICS_END_HINT_PGI = 107012 # GL/glext.h:1949
GL_ALWAYS_FAST_HINT_PGI = 107020 # GL/glext.h:1950
GL_ALWAYS_SOFT_HINT_PGI = 107021 # GL/glext.h:1951
GL_ALLOW_DRAW_OBJ_HINT_PGI = 107022 # GL/glext.h:1952
GL_ALLOW_DRAW_WIN_HINT_PGI = 107023 # GL/glext.h:1953
GL_ALLOW_DRAW_FRG_HINT_PGI = 107024 # GL/glext.h:1954
GL_ALLOW_DRAW_MEM_HINT_PGI = 107025 # GL/glext.h:1955
GL_STRICT_DEPTHFUNC_HINT_PGI = 107030 # GL/glext.h:1956
GL_STRICT_LIGHTING_HINT_PGI = 107031 # GL/glext.h:1957
GL_STRICT_SCISSOR_HINT_PGI = 107032 # GL/glext.h:1958
GL_FULL_STIPPLE_HINT_PGI = 107033 # GL/glext.h:1959
GL_CLIP_NEAR_HINT_PGI = 107040 # GL/glext.h:1960
GL_CLIP_FAR_HINT_PGI = 107041 # GL/glext.h:1961
GL_WIDE_LINE_HINT_PGI = 107042 # GL/glext.h:1962
GL_BACK_NORMALS_HINT_PGI = 107043 # GL/glext.h:1963
# EXT_paletted_texture (GL/glext.h:1966)
GL_COLOR_INDEX1_EXT = 32994 # GL/glext.h:1967
GL_COLOR_INDEX2_EXT = 32995 # GL/glext.h:1968
GL_COLOR_INDEX4_EXT = 32996 # GL/glext.h:1969
GL_COLOR_INDEX8_EXT = 32997 # GL/glext.h:1970
GL_COLOR_INDEX12_EXT = 32998 # GL/glext.h:1971
GL_COLOR_INDEX16_EXT = 32999 # GL/glext.h:1972
GL_TEXTURE_INDEX_SIZE_EXT = 33005 # GL/glext.h:1973
# EXT_clip_volume_hint (GL/glext.h:1976)
GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 33008 # GL/glext.h:1977
# SGIX_list_priority (GL/glext.h:1980)
GL_LIST_PRIORITY_SGIX = 33154 # GL/glext.h:1981
# SGIX_ir_instrument1 (GL/glext.h:1984)
GL_IR_INSTRUMENT1_SGIX = 33151 # GL/glext.h:1985
# SGIX_calligraphic_fragment (GL/glext.h:1988)
GL_CALLIGRAPHIC_FRAGMENT_SGIX = 33155 # GL/glext.h:1989
# SGIX_texture_lod_bias (GL/glext.h:1992)
GL_TEXTURE_LOD_BIAS_S_SGIX = 33166 # GL/glext.h:1993
GL_TEXTURE_LOD_BIAS_T_SGIX = 33167 # GL/glext.h:1994
GL_TEXTURE_LOD_BIAS_R_SGIX = 33168 # GL/glext.h:1995
# SGIX_shadow_ambient (GL/glext.h:1998)
GL_SHADOW_AMBIENT_SGIX = 32959 # GL/glext.h:1999
# EXT_index_texture (GL/glext.h:2002)
# EXT_index_material (GL/glext.h:2005)
GL_INDEX_MATERIAL_EXT = 33208 # GL/glext.h:2006
GL_INDEX_MATERIAL_PARAMETER_EXT = 33209 # GL/glext.h:2007
GL_INDEX_MATERIAL_FACE_EXT = 33210 # GL/glext.h:2008
# EXT_index_func (GL/glext.h:2011)
GL_INDEX_TEST_EXT = 33205 # GL/glext.h:2012
GL_INDEX_TEST_FUNC_EXT = 33206 # GL/glext.h:2013
GL_INDEX_TEST_REF_EXT = 33207 # GL/glext.h:2014
# EXT_index_array_formats (GL/glext.h:2017)
GL_IUI_V2F_EXT = 33197 # GL/glext.h:2018
GL_IUI_V3F_EXT = 33198 # GL/glext.h:2019
GL_IUI_N3F_V2F_EXT = 33199 # GL/glext.h:2020
GL_IUI_N3F_V3F_EXT = 33200 # GL/glext.h:2021
GL_T2F_IUI_V2F_EXT = 33201 # GL/glext.h:2022
GL_T2F_IUI_V3F_EXT = 33202 # GL/glext.h:2023
GL_T2F_IUI_N3F_V2F_EXT = 33203 # GL/glext.h:2024
GL_T2F_IUI_N3F_V3F_EXT = 33204 # GL/glext.h:2025
# EXT_compiled_vertex_array (GL/glext.h:2028)
GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 33192 # GL/glext.h:2029
GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 33193 # GL/glext.h:2030
# EXT_cull_vertex (GL/glext.h:2033)
GL_CULL_VERTEX_EXT = 33194 # GL/glext.h:2034
GL_CULL_VERTEX_EYE_POSITION_EXT = 33195 # GL/glext.h:2035
GL_CULL_VERTEX_OBJECT_POSITION_EXT = 33196 # GL/glext.h:2036
# SGIX_ycrcb (GL/glext.h:2039)
GL_YCRCB_422_SGIX = 33211 # GL/glext.h:2040
GL_YCRCB_444_SGIX = 33212 # GL/glext.h:2041
# SGIX_fragment_lighting (GL/glext.h:2044)
GL_FRAGMENT_LIGHTING_SGIX = 33792 # GL/glext.h:2045
GL_FRAGMENT_COLOR_MATERIAL_SGIX = 33793 # GL/glext.h:2046
GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 33794 # GL/glext.h:2047
GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 33795 # GL/glext.h:2048
GL_MAX_FRAGMENT_LIGHTS_SGIX = 33796 # GL/glext.h:2049
GL_MAX_ACTIVE_LIGHTS_SGIX = 33797 # GL/glext.h:2050
GL_CURRENT_RASTER_NORMAL_SGIX = 33798 # GL/glext.h:2051
GL_LIGHT_ENV_MODE_SGIX = 33799 # GL/glext.h:2052
GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 33800 # GL/glext.h:2053
GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 33801 # GL/glext.h:2054
GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 33802 # GL/glext.h:2055
GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 33803 # GL/glext.h:2056
GL_FRAGMENT_LIGHT0_SGIX = 33804 # GL/glext.h:2057
GL_FRAGMENT_LIGHT1_SGIX = 33805 # GL/glext.h:2058
GL_FRAGMENT_LIGHT2_SGIX = 33806 # GL/glext.h:2059
GL_FRAGMENT_LIGHT3_SGIX = 33807 # GL/glext.h:2060
GL_FRAGMENT_LIGHT4_SGIX = 33808 # GL/glext.h:2061
GL_FRAGMENT_LIGHT5_SGIX = 33809 # GL/glext.h:2062
GL_FRAGMENT_LIGHT6_SGIX = 33810 # GL/glext.h:2063
GL_FRAGMENT_LIGHT7_SGIX = 33811 # GL/glext.h:2064
# IBM_rasterpos_clip (GL/glext.h:2067)
GL_RASTER_POSITION_UNCLIPPED_IBM = 103010 # GL/glext.h:2068
# HP_texture_lighting (GL/glext.h:2071)
GL_TEXTURE_LIGHTING_MODE_HP = 33127 # GL/glext.h:2072
GL_TEXTURE_POST_SPECULAR_HP = 33128 # GL/glext.h:2073
GL_TEXTURE_PRE_SPECULAR_HP = 33129 # GL/glext.h:2074
# EXT_draw_range_elements (GL/glext.h:2077)
GL_MAX_ELEMENTS_VERTICES_EXT = 33000 # GL/glext.h:2078
GL_MAX_ELEMENTS_INDICES_EXT = 33001 # GL/glext.h:2079
# WIN_phong_shading (GL/glext.h:2082)
GL_PHONG_WIN = 33002 # GL/glext.h:2083
GL_PHONG_HINT_WIN = 33003 # GL/glext.h:2084
# WIN_specular_fog (GL/glext.h:2087)
GL_FOG_SPECULAR_TEXTURE_WIN = 33004 # GL/glext.h:2088
# EXT_light_texture (GL/glext.h:2091)
GL_FRAGMENT_MATERIAL_EXT = 33609 # GL/glext.h:2092
GL_FRAGMENT_NORMAL_EXT = 33610 # GL/glext.h:2093
GL_FRAGMENT_COLOR_EXT = 33612 # GL/glext.h:2094
GL_ATTENUATION_EXT = 33613 # GL/glext.h:2095
GL_SHADOW_ATTENUATION_EXT = 33614 # GL/glext.h:2096
GL_TEXTURE_APPLICATION_MODE_EXT = 33615 # GL/glext.h:2097
GL_TEXTURE_LIGHT_EXT = 33616 # GL/glext.h:2098
GL_TEXTURE_MATERIAL_FACE_EXT = 33617 # GL/glext.h:2099
GL_TEXTURE_MATERIAL_PARAMETER_EXT = 33618 # GL/glext.h:2100
# SGIX_blend_alpha_minmax (GL/glext.h:2104)
GL_ALPHA_MIN_SGIX = 33568 # GL/glext.h:2105
GL_ALPHA_MAX_SGIX = 33569 # GL/glext.h:2106
# SGIX_impact_pixel_texture (GL/glext.h:2109)
GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = 33156 # GL/glext.h:2110
GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = 33157 # GL/glext.h:2111
GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = 33158 # GL/glext.h:2112
GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 33159 # GL/glext.h:2113
GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 33160 # GL/glext.h:2114
GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = 33161 # GL/glext.h:2115
GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = 33162 # GL/glext.h:2116
# EXT_bgra (GL/glext.h:2119)
GL_BGR_EXT = 32992 # GL/glext.h:2120
GL_BGRA_EXT = 32993 # GL/glext.h:2121
# SGIX_async (GL/glext.h:2124)
GL_ASYNC_MARKER_SGIX = 33577 # GL/glext.h:2125
# SGIX_async_pixel (GL/glext.h:2128)
GL_ASYNC_TEX_IMAGE_SGIX = 33628 # GL/glext.h:2129
GL_ASYNC_DRAW_PIXELS_SGIX = 33629 # GL/glext.h:2130
GL_ASYNC_READ_PIXELS_SGIX = 33630 # GL/glext.h:2131
GL_MAX_ASYNC_TEX_IMAGE_SGIX = 33631 # GL/glext.h:2132
GL_MAX_ASYNC_DRAW_PIXELS_SGIX = 33632 # GL/glext.h:2133
GL_MAX_ASYNC_READ_PIXELS_SGIX = 33633 # GL/glext.h:2134
# SGIX_async_histogram (GL/glext.h:2137)
GL_ASYNC_HISTOGRAM_SGIX = 33580 # GL/glext.h:2138
GL_MAX_ASYNC_HISTOGRAM_SGIX = 33581 # GL/glext.h:2139
# INTEL_texture_scissor (GL/glext.h:2142)
# INTEL_parallel_arrays (GL/glext.h:2145)
GL_PARALLEL_ARRAYS_INTEL = 33780 # GL/glext.h:2146
GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 33781 # GL/glext.h:2147
GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 33782 # GL/glext.h:2148
GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 33783 # GL/glext.h:2149
GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 33784 # GL/glext.h:2150
# HP_occlusion_test (GL/glext.h:2153)
GL_OCCLUSION_TEST_HP = 33125 # GL/glext.h:2154
GL_OCCLUSION_TEST_RESULT_HP = 33126 # GL/glext.h:2155
# EXT_pixel_transform (GL/glext.h:2158)
GL_PIXEL_TRANSFORM_2D_EXT = 33584 # GL/glext.h:2159
GL_PIXEL_MAG_FILTER_EXT = 33585 # GL/glext.h:2160
GL_PIXEL_MIN_FILTER_EXT = 33586 # GL/glext.h:2161
GL_PIXEL_CUBIC_WEIGHT_EXT = 33587 # GL/glext.h:2162
GL_CUBIC_EXT = 33588 # GL/glext.h:2163
GL_AVERAGE_EXT = 33589 # GL/glext.h:2164
GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 33590 # GL/glext.h:2165
GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 33591 # GL/glext.h:2166
GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = 33592 # GL/glext.h:2167
# EXT_pixel_transform_color_table (GL/glext.h:2170)
# EXT_shared_texture_palette (GL/glext.h:2173)
GL_SHARED_TEXTURE_PALETTE_EXT = 33275 # GL/glext.h:2174
# EXT_separate_specular_color (GL/glext.h:2177)
GL_LIGHT_MODEL_COLOR_CONTROL_EXT = 33272 # GL/glext.h:2178
GL_SINGLE_COLOR_EXT = 33273 # GL/glext.h:2179
GL_SEPARATE_SPECULAR_COLOR_EXT = 33274 # GL/glext.h:2180
# EXT_secondary_color (GL/glext.h:2183)
GL_COLOR_SUM_EXT = 33880 # GL/glext.h:2184
GL_CURRENT_SECONDARY_COLOR_EXT = 33881 # GL/glext.h:2185
GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 33882 # GL/glext.h:2186
GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 33883 # GL/glext.h:2187
GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 33884 # GL/glext.h:2188
GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 33885 # GL/glext.h:2189
GL_SECONDARY_COLOR_ARRAY_EXT = 33886 # GL/glext.h:2190
# EXT_texture_perturb_normal (GL/glext.h:2193)
GL_PERTURB_EXT = 34222 # GL/glext.h:2194
GL_TEXTURE_NORMAL_EXT = 34223 # GL/glext.h:2195
# EXT_multi_draw_arrays (GL/glext.h:2198)
# EXT_fog_coord (GL/glext.h:2201)
GL_FOG_COORDINATE_SOURCE_EXT = 33872 # GL/glext.h:2202
GL_FOG_COORDINATE_EXT = 33873 # GL/glext.h:2203
GL_FRAGMENT_DEPTH_EXT = 33874 # GL/glext.h:2204
GL_CURRENT_FOG_COORDINATE_EXT = 33875 # GL/glext.h:2205
GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 33876 # GL/glext.h:2206
GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 33877 # GL/glext.h:2207
GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 33878 # GL/glext.h:2208
GL_FOG_COORDINATE_ARRAY_EXT = 33879 # GL/glext.h:2209
# REND_screen_coordinates (GL/glext.h:2212)
GL_SCREEN_COORDINATES_REND = 33936 # GL/glext.h:2213
GL_INVERTED_SCREEN_W_REND = 33937 # GL/glext.h:2214
# EXT_coordinate_frame (GL/glext.h:2217)
GL_TANGENT_ARRAY_EXT = 33849 # GL/glext.h:2218
GL_BINORMAL_ARRAY_EXT = 33850 # GL/glext.h:2219
GL_CURRENT_TANGENT_EXT = 33851 # GL/glext.h:2220
GL_CURRENT_BINORMAL_EXT = 33852 # GL/glext.h:2221
GL_TANGENT_ARRAY_TYPE_EXT = 33854 # GL/glext.h:2222
GL_TANGENT_ARRAY_STRIDE_EXT = 33855 # GL/glext.h:2223
GL_BINORMAL_ARRAY_TYPE_EXT = 33856 # GL/glext.h:2224
GL_BINORMAL_ARRAY_STRIDE_EXT = 33857 # GL/glext.h:2225
GL_TANGENT_ARRAY_POINTER_EXT = 33858 # GL/glext.h:2226
GL_BINORMAL_ARRAY_POINTER_EXT = 33859 # GL/glext.h:2227
GL_MAP1_TANGENT_EXT = 33860 # GL/glext.h:2228
GL_MAP2_TANGENT_EXT = 33861 # GL/glext.h:2229
GL_MAP1_BINORMAL_EXT = 33862 # GL/glext.h:2230
GL_MAP2_BINORMAL_EXT = 33863 # GL/glext.h:2231
# EXT_texture_env_combine (GL/glext.h:2234)
GL_COMBINE_EXT = 34160 # GL/glext.h:2235
GL_COMBINE_RGB_EXT = 34161 # GL/glext.h:2236
GL_COMBINE_ALPHA_EXT = 34162 # GL/glext.h:2237
GL_RGB_SCALE_EXT = 34163 # GL/glext.h:2238
GL_ADD_SIGNED_EXT = 34164 # GL/glext.h:2239
GL_INTERPOLATE_EXT = 34165 # GL/glext.h:2240
GL_CONSTANT_EXT = 34166 # GL/glext.h:2241
GL_PRIMARY_COLOR_EXT = 34167 # GL/glext.h:2242
GL_PREVIOUS_EXT = 34168 # GL/glext.h:2243
GL_SOURCE0_RGB_EXT = 34176 # GL/glext.h:2244
GL_SOURCE1_RGB_EXT = 34177 # GL/glext.h:2245
GL_SOURCE2_RGB_EXT = 34178 # GL/glext.h:2246
GL_SOURCE0_ALPHA_EXT = 34184 # GL/glext.h:2247
GL_SOURCE1_ALPHA_EXT = 34185 # GL/glext.h:2248
GL_SOURCE2_ALPHA_EXT = 34186 # GL/glext.h:2249
GL_OPERAND0_RGB_EXT = 34192 # GL/glext.h:2250
GL_OPERAND1_RGB_EXT = 34193 # GL/glext.h:2251
GL_OPERAND2_RGB_EXT = 34194 # GL/glext.h:2252
GL_OPERAND0_ALPHA_EXT = 34200 # GL/glext.h:2253
GL_OPERAND1_ALPHA_EXT = 34201 # GL/glext.h:2254
GL_OPERAND2_ALPHA_EXT = 34202 # GL/glext.h:2255
# APPLE_specular_vector (GL/glext.h:2258)
GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 34224 # GL/glext.h:2259
# APPLE_transform_hint (GL/glext.h:2262)
GL_TRANSFORM_HINT_APPLE = 34225 # GL/glext.h:2263
# SGIX_fog_scale (GL/glext.h:2266)
GL_FOG_SCALE_SGIX = 33276 # GL/glext.h:2267
GL_FOG_SCALE_VALUE_SGIX = 33277 # GL/glext.h:2268
# SUNX_constant_data (GL/glext.h:2271)
GL_UNPACK_CONSTANT_DATA_SUNX = 33237 # GL/glext.h:2272
GL_TEXTURE_CONSTANT_DATA_SUNX = 33238 # GL/glext.h:2273
# SUN_global_alpha (GL/glext.h:2276)
GL_GLOBAL_ALPHA_SUN = 33241 # GL/glext.h:2277
GL_GLOBAL_ALPHA_FACTOR_SUN = 33242 # GL/glext.h:2278
# SUN_triangle_list (GL/glext.h:2281)
GL_RESTART_SUN = 1 # GL/glext.h:2282
GL_REPLACE_MIDDLE_SUN = 2 # GL/glext.h:2283
GL_REPLACE_OLDEST_SUN = 3 # GL/glext.h:2284
GL_TRIANGLE_LIST_SUN = 33239 # GL/glext.h:2285
GL_REPLACEMENT_CODE_SUN = 33240 # GL/glext.h:2286
GL_REPLACEMENT_CODE_ARRAY_SUN = 34240 # GL/glext.h:2287
GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 34241 # GL/glext.h:2288
GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 34242 # GL/glext.h:2289
GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 34243 # GL/glext.h:2290
GL_R1UI_V3F_SUN = 34244 # GL/glext.h:2291
GL_R1UI_C4UB_V3F_SUN = 34245 # GL/glext.h:2292
GL_R1UI_C3F_V3F_SUN = 34246 # GL/glext.h:2293
GL_R1UI_N3F_V3F_SUN = 34247 # GL/glext.h:2294
GL_R1UI_C4F_N3F_V3F_SUN = 34248 # GL/glext.h:2295
GL_R1UI_T2F_V3F_SUN = 34249 # GL/glext.h:2296
GL_R1UI_T2F_N3F_V3F_SUN = 34250 # GL/glext.h:2297
GL_R1UI_T2F_C4F_N3F_V3F_SUN = 34251 # GL/glext.h:2298
# SUN_vertex (GL/glext.h:2301)
# EXT_blend_func_separate (GL/glext.h:2304)
GL_BLEND_DST_RGB_EXT = 32968 # GL/glext.h:2305
GL_BLEND_SRC_RGB_EXT = 32969 # GL/glext.h:2306
GL_BLEND_DST_ALPHA_EXT = 32970 # GL/glext.h:2307
GL_BLEND_SRC_ALPHA_EXT = 32971 # GL/glext.h:2308
# INGR_color_clamp (GL/glext.h:2311)
GL_RED_MIN_CLAMP_INGR = 34144 # GL/glext.h:2312
GL_GREEN_MIN_CLAMP_INGR = 34145 # GL/glext.h:2313
GL_BLUE_MIN_CLAMP_INGR = 34146 # GL/glext.h:2314
GL_ALPHA_MIN_CLAMP_INGR = 34147 # GL/glext.h:2315
GL_RED_MAX_CLAMP_INGR = 34148 # GL/glext.h:2316
GL_GREEN_MAX_CLAMP_INGR = 34149 # GL/glext.h:2317
GL_BLUE_MAX_CLAMP_INGR = 34150 # GL/glext.h:2318
GL_ALPHA_MAX_CLAMP_INGR = 34151 # GL/glext.h:2319
# INGR_interlace_read (GL/glext.h:2322)
GL_INTERLACE_READ_INGR = 34152 # GL/glext.h:2323
# EXT_stencil_wrap (GL/glext.h:2326)
GL_INCR_WRAP_EXT = 34055 # GL/glext.h:2327
GL_DECR_WRAP_EXT = 34056 # GL/glext.h:2328
# EXT_422_pixels (GL/glext.h:2331)
GL_422_EXT = 32972 # GL/glext.h:2332
GL_422_REV_EXT = 32973 # GL/glext.h:2333
GL_422_AVERAGE_EXT = 32974 # GL/glext.h:2334
GL_422_REV_AVERAGE_EXT = 32975 # GL/glext.h:2335
# NV_texgen_reflection (GL/glext.h:2338)
GL_NORMAL_MAP_NV = 34065 # GL/glext.h:2339
GL_REFLECTION_MAP_NV = 34066 # GL/glext.h:2340
# EXT_texture_cube_map (GL/glext.h:2343)
GL_NORMAL_MAP_EXT = 34065 # GL/glext.h:2344
GL_REFLECTION_MAP_EXT = 34066 # GL/glext.h:2345
GL_TEXTURE_CUBE_MAP_EXT = 34067 # GL/glext.h:2346
GL_TEXTURE_BINDING_CUBE_MAP_EXT = 34068 # GL/glext.h:2347
GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 34069 # GL/glext.h:2348
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 34070 # GL/glext.h:2349
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 34071 # GL/glext.h:2350
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 34072 # GL/glext.h:2351
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 34073 # GL/glext.h:2352
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 34074 # GL/glext.h:2353
GL_PROXY_TEXTURE_CUBE_MAP_EXT = 34075 # GL/glext.h:2354
GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 34076 # GL/glext.h:2355
# SUN_convolution_border_modes (GL/glext.h:2358)
GL_WRAP_BORDER_SUN = 33236 # GL/glext.h:2359
# EXT_texture_env_add (GL/glext.h:2362)
# EXT_texture_lod_bias (GL/glext.h:2365)
GL_MAX_TEXTURE_LOD_BIAS_EXT = 34045 # GL/glext.h:2366
GL_TEXTURE_FILTER_CONTROL_EXT = 34048 # GL/glext.h:2367
GL_TEXTURE_LOD_BIAS_EXT = 34049 # GL/glext.h:2368
# EXT_texture_filter_anisotropic (GL/glext.h:2371)
GL_TEXTURE_MAX_ANISOTROPY_EXT = 34046 # GL/glext.h:2372
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047 # GL/glext.h:2373
# EXT_vertex_weighting (GL/glext.h:2376)
GL_MODELVIEW0_STACK_DEPTH_EXT = 2979 # GL/glext.h:2377
GL_MODELVIEW1_STACK_DEPTH_EXT = 34050 # GL/glext.h:2378
GL_MODELVIEW0_MATRIX_EXT = 2982 # GL/glext.h:2379
GL_MODELVIEW1_MATRIX_EXT = 34054 # GL/glext.h:2380
GL_VERTEX_WEIGHTING_EXT = 34057 # GL/glext.h:2381
GL_MODELVIEW0_EXT = 5888 # GL/glext.h:2382
GL_MODELVIEW1_EXT = 34058 # GL/glext.h:2383
GL_CURRENT_VERTEX_WEIGHT_EXT = 34059 # GL/glext.h:2384
GL_VERTEX_WEIGHT_ARRAY_EXT = 34060 # GL/glext.h:2385
GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 34061 # GL/glext.h:2386
GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 34062 # GL/glext.h:2387
GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 34063 # GL/glext.h:2388
GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 34064 # GL/glext.h:2389
# NV_light_max_exponent (GL/glext.h:2392)
GL_MAX_SHININESS_NV = 34052 # GL/glext.h:2393
GL_MAX_SPOT_EXPONENT_NV = 34053 # GL/glext.h:2394
# NV_vertex_array_range (GL/glext.h:2397)
GL_VERTEX_ARRAY_RANGE_NV = 34077 # GL/glext.h:2398
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 34078 # GL/glext.h:2399
GL_VERTEX_ARRAY_RANGE_VALID_NV = 34079 # GL/glext.h:2400
GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 34080 # GL/glext.h:2401
GL_VERTEX_ARRAY_RANGE_POINTER_NV = 34081 # GL/glext.h:2402
# NV_register_combiners (GL/glext.h:2405)
GL_REGISTER_COMBINERS_NV = 34082 # GL/glext.h:2406
GL_VARIABLE_A_NV = 34083 # GL/glext.h:2407
GL_VARIABLE_B_NV = 34084 # GL/glext.h:2408
GL_VARIABLE_C_NV = 34085 # GL/glext.h:2409
GL_VARIABLE_D_NV = 34086 # GL/glext.h:2410
GL_VARIABLE_E_NV = 34087 # GL/glext.h:2411
GL_VARIABLE_F_NV = 34088 # GL/glext.h:2412
GL_VARIABLE_G_NV = 34089 # GL/glext.h:2413
GL_CONSTANT_COLOR0_NV = 34090 # GL/glext.h:2414
GL_CONSTANT_COLOR1_NV = 34091 # GL/glext.h:2415
GL_PRIMARY_COLOR_NV = 34092 # GL/glext.h:2416
GL_SECONDARY_COLOR_NV = 34093 # GL/glext.h:2417
GL_SPARE0_NV = 34094 # GL/glext.h:2418
GL_SPARE1_NV = 34095 # GL/glext.h:2419
GL_DISCARD_NV = 34096 # GL/glext.h:2420
GL_E_TIMES_F_NV = 34097 # GL/glext.h:2421
GL_SPARE0_PLUS_SECONDARY_COLOR_NV = 34098 # GL/glext.h:2422
GL_UNSIGNED_IDENTITY_NV = 34102 # GL/glext.h:2423
GL_UNSIGNED_INVERT_NV = 34103 # GL/glext.h:2424
GL_EXPAND_NORMAL_NV = 34104 # GL/glext.h:2425
GL_EXPAND_NEGATE_NV = 34105 # GL/glext.h:2426
GL_HALF_BIAS_NORMAL_NV = 34106 # GL/glext.h:2427
GL_HALF_BIAS_NEGATE_NV = 34107 # GL/glext.h:2428
GL_SIGNED_IDENTITY_NV = 34108 # GL/glext.h:2429
GL_SIGNED_NEGATE_NV = 34109 # GL/glext.h:2430
GL_SCALE_BY_TWO_NV = 34110 # GL/glext.h:2431
GL_SCALE_BY_FOUR_NV = 34111 # GL/glext.h:2432
GL_SCALE_BY_ONE_HALF_NV = 34112 # GL/glext.h:2433
GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 34113 # GL/glext.h:2434
GL_COMBINER_INPUT_NV = 34114 # GL/glext.h:2435
GL_COMBINER_MAPPING_NV = 34115 # GL/glext.h:2436
GL_COMBINER_COMPONENT_USAGE_NV = 34116 # GL/glext.h:2437
GL_COMBINER_AB_DOT_PRODUCT_NV = 34117 # GL/glext.h:2438
GL_COMBINER_CD_DOT_PRODUCT_NV = 34118 # GL/glext.h:2439
GL_COMBINER_MUX_SUM_NV = 34119 # GL/glext.h:2440
GL_COMBINER_SCALE_NV = 34120 # GL/glext.h:2441
GL_COMBINER_BIAS_NV = 34121 # GL/glext.h:2442
GL_COMBINER_AB_OUTPUT_NV = 34122 # GL/glext.h:2443
GL_COMBINER_CD_OUTPUT_NV = 34123 # GL/glext.h:2444
GL_COMBINER_SUM_OUTPUT_NV = 34124 # GL/glext.h:2445
GL_MAX_GENERAL_COMBINERS_NV = 34125 # GL/glext.h:2446
GL_NUM_GENERAL_COMBINERS_NV = 34126 # GL/glext.h:2447
GL_COLOR_SUM_CLAMP_NV = 34127 # GL/glext.h:2448
GL_COMBINER0_NV = 34128 # GL/glext.h:2449
GL_COMBINER1_NV = 34129 # GL/glext.h:2450
GL_COMBINER2_NV = 34130 # GL/glext.h:2451
GL_COMBINER3_NV = 34131 # GL/glext.h:2452
GL_COMBINER4_NV = 34132 # GL/glext.h:2453
GL_COMBINER5_NV = 34133 # GL/glext.h:2454
GL_COMBINER6_NV = 34134 # GL/glext.h:2455
GL_COMBINER7_NV = 34135 # GL/glext.h:2456
# NV_fog_distance (GL/glext.h:2464)
GL_FOG_DISTANCE_MODE_NV = 34138 # GL/glext.h:2465
GL_EYE_RADIAL_NV = 34139 # GL/glext.h:2466
GL_EYE_PLANE_ABSOLUTE_NV = 34140 # GL/glext.h:2467
# NV_texgen_emboss (GL/glext.h:2471)
GL_EMBOSS_LIGHT_NV = 34141 # GL/glext.h:2472
GL_EMBOSS_CONSTANT_NV = 34142 # GL/glext.h:2473
GL_EMBOSS_MAP_NV = 34143 # GL/glext.h:2474
# NV_blend_square (GL/glext.h:2477)
# NV_texture_env_combine4 (GL/glext.h:2480)
GL_COMBINE4_NV = 34051 # GL/glext.h:2481
GL_SOURCE3_RGB_NV = 34179 # GL/glext.h:2482
GL_SOURCE3_ALPHA_NV = 34187 # GL/glext.h:2483
GL_OPERAND3_RGB_NV = 34195 # GL/glext.h:2484
GL_OPERAND3_ALPHA_NV = 34203 # GL/glext.h:2485
# MESA_resize_buffers (GL/glext.h:2488)
# MESA_window_pos (GL/glext.h:2491)
# EXT_texture_compression_s3tc (GL/glext.h:2494)
GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776 # GL/glext.h:2495
GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777 # GL/glext.h:2496
GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778 # GL/glext.h:2497
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779 # GL/glext.h:2498
# IBM_cull_vertex (GL/glext.h:2501)
GL_CULL_VERTEX_IBM = 103050 # GL/glext.h:2502
# IBM_multimode_draw_arrays (GL/glext.h:2505)
# IBM_vertex_array_lists (GL/glext.h:2508)
GL_VERTEX_ARRAY_LIST_IBM = 103070 # GL/glext.h:2509
GL_NORMAL_ARRAY_LIST_IBM = 103071 # GL/glext.h:2510
GL_COLOR_ARRAY_LIST_IBM = 103072 # GL/glext.h:2511
GL_INDEX_ARRAY_LIST_IBM = 103073 # GL/glext.h:2512
GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074 # GL/glext.h:2513
GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075 # GL/glext.h:2514
GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076 # GL/glext.h:2515
GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077 # GL/glext.h:2516
GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080 # GL/glext.h:2517
GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081 # GL/glext.h:2518
GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082 # GL/glext.h:2519
GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083 # GL/glext.h:2520
GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084 # GL/glext.h:2521
GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085 # GL/glext.h:2522
GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086 # GL/glext.h:2523
GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087 # GL/glext.h:2524
# SGIX_subsample (GL/glext.h:2527)
GL_PACK_SUBSAMPLE_RATE_SGIX = 34208 # GL/glext.h:2528
GL_UNPACK_SUBSAMPLE_RATE_SGIX = 34209 # GL/glext.h:2529
GL_PIXEL_SUBSAMPLE_4444_SGIX = 34210 # GL/glext.h:2530
GL_PIXEL_SUBSAMPLE_2424_SGIX = 34211 # GL/glext.h:2531
GL_PIXEL_SUBSAMPLE_4242_SGIX = 34212 # GL/glext.h:2532
# SGIX_ycrcb_subsample (GL/glext.h:2535)
# SGIX_ycrcba (GL/glext.h:2538)
GL_YCRCB_SGIX = 33560 # GL/glext.h:2539
GL_YCRCBA_SGIX = 33561 # GL/glext.h:2540
# SGI_depth_pass_instrument (GL/glext.h:2543)
GL_DEPTH_PASS_INSTRUMENT_SGIX = 33552 # GL/glext.h:2544
GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 33553 # GL/glext.h:2545
GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = 33554 # GL/glext.h:2546
# 3DFX_texture_compression_FXT1 (GL/glext.h:2549)
GL_COMPRESSED_RGB_FXT1_3DFX = 34480 # GL/glext.h:2550
GL_COMPRESSED_RGBA_FXT1_3DFX = 34481 # GL/glext.h:2551
# 3DFX_multisample (GL/glext.h:2554)
GL_MULTISAMPLE_3DFX = 34482 # GL/glext.h:2555
GL_SAMPLE_BUFFERS_3DFX = 34483 # GL/glext.h:2556
GL_SAMPLES_3DFX = 34484 # GL/glext.h:2557
GL_MULTISAMPLE_BIT_3DFX = 536870912 # GL/glext.h:2558
# 3DFX_tbuffer (GL/glext.h:2561)
# EXT_multisample (GL/glext.h:2564)
GL_MULTISAMPLE_EXT = 32925 # GL/glext.h:2565
GL_SAMPLE_ALPHA_TO_MASK_EXT = 32926 # GL/glext.h:2566
GL_SAMPLE_ALPHA_TO_ONE_EXT = 32927 # GL/glext.h:2567
GL_SAMPLE_MASK_EXT = 32928 # GL/glext.h:2568
GL_1PASS_EXT = 32929 # GL/glext.h:2569
GL_2PASS_0_EXT = 32930 # GL/glext.h:2570
GL_2PASS_1_EXT = 32931 # GL/glext.h:2571
GL_4PASS_0_EXT = 32932 # GL/glext.h:2572
GL_4PASS_1_EXT = 32933 # GL/glext.h:2573
GL_4PASS_2_EXT = 32934 # GL/glext.h:2574
GL_4PASS_3_EXT = 32935 # GL/glext.h:2575
GL_SAMPLE_BUFFERS_EXT = 32936 # GL/glext.h:2576
GL_SAMPLES_EXT = 32937 # GL/glext.h:2577
GL_SAMPLE_MASK_VALUE_EXT = 32938 # GL/glext.h:2578
GL_SAMPLE_MASK_INVERT_EXT = 32939 # GL/glext.h:2579
GL_SAMPLE_PATTERN_EXT = 32940 # GL/glext.h:2580
GL_MULTISAMPLE_BIT_EXT = 536870912 # GL/glext.h:2581
# SGIX_vertex_preclip (GL/glext.h:2584)
GL_VERTEX_PRECLIP_SGIX = 33774 # GL/glext.h:2585
GL_VERTEX_PRECLIP_HINT_SGIX = 33775 # GL/glext.h:2586
# SGIX_convolution_accuracy (GL/glext.h:2589)
GL_CONVOLUTION_HINT_SGIX = 33558 # GL/glext.h:2590
# SGIX_resample (GL/glext.h:2593)
GL_PACK_RESAMPLE_SGIX = 33836 # GL/glext.h:2594
GL_UNPACK_RESAMPLE_SGIX = 33837 # GL/glext.h:2595
GL_RESAMPLE_REPLICATE_SGIX = 33838 # GL/glext.h:2596
GL_RESAMPLE_ZERO_FILL_SGIX = 33839 # GL/glext.h:2597
GL_RESAMPLE_DECIMATE_SGIX = 33840 # GL/glext.h:2598
# SGIS_point_line_texgen (GL/glext.h:2601)
GL_EYE_DISTANCE_TO_POINT_SGIS = 33264 # GL/glext.h:2602
GL_OBJECT_DISTANCE_TO_POINT_SGIS = 33265 # GL/glext.h:2603
GL_EYE_DISTANCE_TO_LINE_SGIS = 33266 # GL/glext.h:2604
GL_OBJECT_DISTANCE_TO_LINE_SGIS = 33267 # GL/glext.h:2605
GL_EYE_POINT_SGIS = 33268 # GL/glext.h:2606
GL_OBJECT_POINT_SGIS = 33269 # GL/glext.h:2607
GL_EYE_LINE_SGIS = 33270 # GL/glext.h:2608
GL_OBJECT_LINE_SGIS = 33271 # GL/glext.h:2609
# SGIS_texture_color_mask (GL/glext.h:2612)
GL_TEXTURE_COLOR_WRITEMASK_SGIS = 33263 # GL/glext.h:2613
# EXT_texture_env_dot3 (GL/glext.h:2616)
GL_DOT3_RGB_EXT = 34624 # GL/glext.h:2617
GL_DOT3_RGBA_EXT = 34625 # GL/glext.h:2618
# ATI_texture_mirror_once (GL/glext.h:2621)
GL_MIRROR_CLAMP_ATI = 34626 # GL/glext.h:2622
GL_MIRROR_CLAMP_TO_EDGE_ATI = 34627 # GL/glext.h:2623
# NV_fence (GL/glext.h:2626)
GL_ALL_COMPLETED_NV = 34034 # GL/glext.h:2627
GL_FENCE_STATUS_NV = 34035 # GL/glext.h:2628
GL_FENCE_CONDITION_NV = 34036 # GL/glext.h:2629
# IBM_texture_mirrored_repeat (GL/glext.h:2632)
GL_MIRRORED_REPEAT_IBM = 33648 # GL/glext.h:2633
# NV_evaluators (GL/glext.h:2636)
GL_EVAL_2D_NV = 34496 # GL/glext.h:2637
GL_EVAL_TRIANGULAR_2D_NV = 34497 # GL/glext.h:2638
GL_MAP_TESSELLATION_NV = 34498 # GL/glext.h:2639
GL_MAP_ATTRIB_U_ORDER_NV = 34499 # GL/glext.h:2640
GL_MAP_ATTRIB_V_ORDER_NV = 34500 # GL/glext.h:2641
GL_EVAL_FRACTIONAL_TESSELLATION_NV = 34501 # GL/glext.h:2642
GL_EVAL_VERTEX_ATTRIB0_NV = 34502 # GL/glext.h:2643
GL_EVAL_VERTEX_ATTRIB1_NV = 34503 # GL/glext.h:2644
GL_EVAL_VERTEX_ATTRIB2_NV = 34504 # GL/glext.h:2645
GL_EVAL_VERTEX_ATTRIB3_NV = 34505 # GL/glext.h:2646
GL_EVAL_VERTEX_ATTRIB4_NV = 34506 # GL/glext.h:2647
GL_EVAL_VERTEX_ATTRIB5_NV = 34507 # GL/glext.h:2648
GL_EVAL_VERTEX_ATTRIB6_NV = 34508 # GL/glext.h:2649
GL_EVAL_VERTEX_ATTRIB7_NV = 34509 # GL/glext.h:2650
GL_EVAL_VERTEX_ATTRIB8_NV = 34510 # GL/glext.h:2651
GL_EVAL_VERTEX_ATTRIB9_NV = 34511 # GL/glext.h:2652
GL_EVAL_VERTEX_ATTRIB10_NV = 34512 # GL/glext.h:2653
GL_EVAL_VERTEX_ATTRIB11_NV = 34513 # GL/glext.h:2654
GL_EVAL_VERTEX_ATTRIB12_NV = 34514 # GL/glext.h:2655
GL_EVAL_VERTEX_ATTRIB13_NV = 34515 # GL/glext.h:2656
GL_EVAL_VERTEX_ATTRIB14_NV = 34516 # GL/glext.h:2657
GL_EVAL_VERTEX_ATTRIB15_NV = 34517 # GL/glext.h:2658
GL_MAX_MAP_TESSELLATION_NV = 34518 # GL/glext.h:2659
GL_MAX_RATIONAL_EVAL_ORDER_NV = 34519 # GL/glext.h:2660
# NV_packed_depth_stencil (GL/glext.h:2663)
GL_DEPTH_STENCIL_NV = 34041 # GL/glext.h:2664
GL_UNSIGNED_INT_24_8_NV = 34042 # GL/glext.h:2665
# EXT_packed_depth_stencil (GL/glext.h:2668)
GL_DEPTH_STENCIL_EXT = 34041 # GL/glext.h:2669
GL_DEPTH24_STENCIL8_EXT = 35056 # GL/glext.h:2670
GL_TEXTURE_STENCIL_SIZE_EXT = 35057 # GL/glext.h:2671
GL_UNSIGNED_INT_24_8_EXT = 34042 # GL/glext.h:2672
# NV_register_combiners2 (GL/glext.h:2675)
GL_PER_STAGE_CONSTANTS_NV = 34101 # GL/glext.h:2676
# NV_texture_compression_vtc (GL/glext.h:2679)
# NV_texture_rectangle (GL/glext.h:2682)
GL_TEXTURE_RECTANGLE_NV = 34037 # GL/glext.h:2683
GL_TEXTURE_BINDING_RECTANGLE_NV = 34038 # GL/glext.h:2684
GL_PROXY_TEXTURE_RECTANGLE_NV = 34039 # GL/glext.h:2685
GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = 34040 # GL/glext.h:2686
# NV_texture_shader (GL/glext.h:2689)
GL_OFFSET_TEXTURE_RECTANGLE_NV = 34380 # GL/glext.h:2690
GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 34381 # GL/glext.h:2691
GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 34382 # GL/glext.h:2692
GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 34521 # GL/glext.h:2693
GL_UNSIGNED_INT_S8_S8_8_8_NV = 34522 # GL/glext.h:2694
GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = 34523 # GL/glext.h:2695
GL_DSDT_MAG_INTENSITY_NV = 34524 # GL/glext.h:2696
GL_SHADER_CONSISTENT_NV = 34525 # GL/glext.h:2697
GL_TEXTURE_SHADER_NV = 34526 # GL/glext.h:2698
GL_SHADER_OPERATION_NV = 34527 # GL/glext.h:2699
GL_CULL_MODES_NV = 34528 # GL/glext.h:2700
GL_OFFSET_TEXTURE_MATRIX_NV = 34529 # GL/glext.h:2701
GL_OFFSET_TEXTURE_SCALE_NV = 34530 # GL/glext.h:2702
GL_OFFSET_TEXTURE_BIAS_NV = 34531 # GL/glext.h:2703
GL_OFFSET_TEXTURE_2D_MATRIX_NV = 34529 # GL/glext.h:2704
GL_OFFSET_TEXTURE_2D_SCALE_NV = 34530 # GL/glext.h:2705
GL_OFFSET_TEXTURE_2D_BIAS_NV = 34531 # GL/glext.h:2706
GL_PREVIOUS_TEXTURE_INPUT_NV = 34532 # GL/glext.h:2707
GL_CONST_EYE_NV = 34533 # GL/glext.h:2708
GL_PASS_THROUGH_NV = 34534 # GL/glext.h:2709
GL_CULL_FRAGMENT_NV = 34535 # GL/glext.h:2710
GL_OFFSET_TEXTURE_2D_NV = 34536 # GL/glext.h:2711
GL_DEPENDENT_AR_TEXTURE_2D_NV = 34537 # GL/glext.h:2712
GL_DEPENDENT_GB_TEXTURE_2D_NV = 34538 # GL/glext.h:2713
GL_DOT_PRODUCT_NV = 34540 # GL/glext.h:2714
GL_DOT_PRODUCT_DEPTH_REPLACE_NV = 34541 # GL/glext.h:2715
GL_DOT_PRODUCT_TEXTURE_2D_NV = 34542 # GL/glext.h:2716
GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 34544 # GL/glext.h:2717
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 34545 # GL/glext.h:2718
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 34546 # GL/glext.h:2719
GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 34547 # GL/glext.h:2720
GL_HILO_NV = 34548 # GL/glext.h:2721
GL_DSDT_NV = 34549 # GL/glext.h:2722
GL_DSDT_MAG_NV = 34550 # GL/glext.h:2723
GL_DSDT_MAG_VIB_NV = 34551 # GL/glext.h:2724
GL_HILO16_NV = 34552 # GL/glext.h:2725
GL_SIGNED_HILO_NV = 34553 # GL/glext.h:2726
GL_SIGNED_HILO16_NV = 34554 # GL/glext.h:2727
GL_SIGNED_RGBA_NV = 34555 # GL/glext.h:2728
GL_SIGNED_RGBA8_NV = 34556 # GL/glext.h:2729
GL_SIGNED_RGB_NV = 34558 # GL/glext.h:2730
GL_SIGNED_RGB8_NV = 34559 # GL/glext.h:2731
GL_SIGNED_LUMINANCE_NV = 34561 # GL/glext.h:2732
GL_SIGNED_LUMINANCE8_NV = 34562 # GL/glext.h:2733
GL_SIGNED_LUMINANCE_ALPHA_NV = 34563 # GL/glext.h:2734
GL_SIGNED_LUMINANCE8_ALPHA8_NV = 34564 # GL/glext.h:2735
GL_SIGNED_ALPHA_NV = 34565 # GL/glext.h:2736
GL_SIGNED_ALPHA8_NV = 34566 # GL/glext.h:2737
GL_SIGNED_INTENSITY_NV = 34567 # GL/glext.h:2738
GL_SIGNED_INTENSITY8_NV = 34568 # GL/glext.h:2739
GL_DSDT8_NV = 34569 # GL/glext.h:2740
GL_DSDT8_MAG8_NV = 34570 # GL/glext.h:2741
GL_DSDT8_MAG8_INTENSITY8_NV = 34571 # GL/glext.h:2742
GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 34572 # GL/glext.h:2743
GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 34573 # GL/glext.h:2744
GL_HI_SCALE_NV = 34574 # GL/glext.h:2745
GL_LO_SCALE_NV = 34575 # GL/glext.h:2746
GL_DS_SCALE_NV = 34576 # GL/glext.h:2747
GL_DT_SCALE_NV = 34577 # GL/glext.h:2748
GL_MAGNITUDE_SCALE_NV = 34578 # GL/glext.h:2749
GL_VIBRANCE_SCALE_NV = 34579 # GL/glext.h:2750
GL_HI_BIAS_NV = 34580 # GL/glext.h:2751
GL_LO_BIAS_NV = 34581 # GL/glext.h:2752
GL_DS_BIAS_NV = 34582 # GL/glext.h:2753
GL_DT_BIAS_NV = 34583 # GL/glext.h:2754
GL_MAGNITUDE_BIAS_NV = 34584 # GL/glext.h:2755
GL_VIBRANCE_BIAS_NV = 34585 # GL/glext.h:2756
GL_TEXTURE_BORDER_VALUES_NV = 34586 # GL/glext.h:2757
GL_TEXTURE_HI_SIZE_NV = 34587 # GL/glext.h:2758
GL_TEXTURE_LO_SIZE_NV = 34588 # GL/glext.h:2759
GL_TEXTURE_DS_SIZE_NV = 34589 # GL/glext.h:2760
GL_TEXTURE_DT_SIZE_NV = 34590 # GL/glext.h:2761
GL_TEXTURE_MAG_SIZE_NV = 34591 # GL/glext.h:2762
# NV_texture_shader2 (GL/glext.h:2765)
GL_DOT_PRODUCT_TEXTURE_3D_NV = 34543 # GL/glext.h:2766
# NV_vertex_array_range2 (GL/glext.h:2769)
GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 34099 # GL/glext.h:2770
# NV_vertex_program (GL/glext.h:2773)
GL_VERTEX_PROGRAM_NV = 34336 # GL/glext.h:2774
GL_VERTEX_STATE_PROGRAM_NV = 34337 # GL/glext.h:2775
GL_ATTRIB_ARRAY_SIZE_NV = 34339 # GL/glext.h:2776
GL_ATTRIB_ARRAY_STRIDE_NV = 34340 # GL/glext.h:2777
GL_ATTRIB_ARRAY_TYPE_NV = 34341 # GL/glext.h:2778
GL_CURRENT_ATTRIB_NV = 34342 # GL/glext.h:2779
GL_PROGRAM_LENGTH_NV = 34343 # GL/glext.h:2780
GL_PROGRAM_STRING_NV = 34344 # GL/glext.h:2781
GL_MODELVIEW_PROJECTION_NV = 34345 # GL/glext.h:2782
GL_IDENTITY_NV = 34346 # GL/glext.h:2783
GL_INVERSE_NV = 34347 # GL/glext.h:2784
GL_TRANSPOSE_NV = 34348 # GL/glext.h:2785
GL_INVERSE_TRANSPOSE_NV = 34349 # GL/glext.h:2786
GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 34350 # GL/glext.h:2787
GL_MAX_TRACK_MATRICES_NV = 34351 # GL/glext.h:2788
GL_MATRIX0_NV = 34352 # GL/glext.h:2789
GL_MATRIX1_NV = 34353 # GL/glext.h:2790
GL_MATRIX2_NV = 34354 # GL/glext.h:2791
GL_MATRIX3_NV = 34355 # GL/glext.h:2792
GL_MATRIX4_NV = 34356 # GL/glext.h:2793
GL_MATRIX5_NV = 34357 # GL/glext.h:2794
GL_MATRIX6_NV = 34358 # GL/glext.h:2795
GL_MATRIX7_NV = 34359 # GL/glext.h:2796
GL_CURRENT_MATRIX_STACK_DEPTH_NV = 34368 # GL/glext.h:2797
GL_CURRENT_MATRIX_NV = 34369 # GL/glext.h:2798
GL_VERTEX_PROGRAM_POINT_SIZE_NV = 34370 # GL/glext.h:2799
GL_VERTEX_PROGRAM_TWO_SIDE_NV = 34371 # GL/glext.h:2800
GL_PROGRAM_PARAMETER_NV = 34372 # GL/glext.h:2801
GL_ATTRIB_ARRAY_POINTER_NV = 34373 # GL/glext.h:2802
GL_PROGRAM_TARGET_NV = 34374 # GL/glext.h:2803
GL_PROGRAM_RESIDENT_NV = 34375 # GL/glext.h:2804
GL_TRACK_MATRIX_NV = 34376 # GL/glext.h:2805
GL_TRACK_MATRIX_TRANSFORM_NV = 34377 # GL/glext.h:2806
GL_VERTEX_PROGRAM_BINDING_NV = 34378 # GL/glext.h:2807
GL_PROGRAM_ERROR_POSITION_NV = 34379 # GL/glext.h:2808
GL_VERTEX_ATTRIB_ARRAY0_NV = 34384 # GL/glext.h:2809
GL_VERTEX_ATTRIB_ARRAY1_NV = 34385 # GL/glext.h:2810
GL_VERTEX_ATTRIB_ARRAY2_NV = 34386 # GL/glext.h:2811
GL_VERTEX_ATTRIB_ARRAY3_NV = 34387 # GL/glext.h:2812
GL_VERTEX_ATTRIB_ARRAY4_NV = 34388 # GL/glext.h:2813
GL_VERTEX_ATTRIB_ARRAY5_NV = 34389 # GL/glext.h:2814
GL_VERTEX_ATTRIB_ARRAY6_NV = 34390 # GL/glext.h:2815
GL_VERTEX_ATTRIB_ARRAY7_NV = 34391 # GL/glext.h:2816
GL_VERTEX_ATTRIB_ARRAY8_NV = 34392 # GL/glext.h:2817
GL_VERTEX_ATTRIB_ARRAY9_NV = 34393 # GL/glext.h:2818
GL_VERTEX_ATTRIB_ARRAY10_NV = 34394 # GL/glext.h:2819
GL_VERTEX_ATTRIB_ARRAY11_NV = 34395 # GL/glext.h:2820
GL_VERTEX_ATTRIB_ARRAY12_NV = 34396 # GL/glext.h:2821
GL_VERTEX_ATTRIB_ARRAY13_NV = 34397 # GL/glext.h:2822
GL_VERTEX_ATTRIB_ARRAY14_NV = 34398 # GL/glext.h:2823
GL_VERTEX_ATTRIB_ARRAY15_NV = 34399 # GL/glext.h:2824
GL_MAP1_VERTEX_ATTRIB0_4_NV = 34400 # GL/glext.h:2825
GL_MAP1_VERTEX_ATTRIB1_4_NV = 34401 # GL/glext.h:2826
GL_MAP1_VERTEX_ATTRIB2_4_NV = 34402 # GL/glext.h:2827
GL_MAP1_VERTEX_ATTRIB3_4_NV = 34403 # GL/glext.h:2828
GL_MAP1_VERTEX_ATTRIB4_4_NV = 34404 # GL/glext.h:2829
GL_MAP1_VERTEX_ATTRIB5_4_NV = 34405 # GL/glext.h:2830
GL_MAP1_VERTEX_ATTRIB6_4_NV = 34406 # GL/glext.h:2831
GL_MAP1_VERTEX_ATTRIB7_4_NV = 34407 # GL/glext.h:2832
GL_MAP1_VERTEX_ATTRIB8_4_NV = 34408 # GL/glext.h:2833
GL_MAP1_VERTEX_ATTRIB9_4_NV = 34409 # GL/glext.h:2834
GL_MAP1_VERTEX_ATTRIB10_4_NV = 34410 # GL/glext.h:2835
GL_MAP1_VERTEX_ATTRIB11_4_NV = 34411 # GL/glext.h:2836
GL_MAP1_VERTEX_ATTRIB12_4_NV = 34412 # GL/glext.h:2837
GL_MAP1_VERTEX_ATTRIB13_4_NV = 34413 # GL/glext.h:2838
GL_MAP1_VERTEX_ATTRIB14_4_NV = 34414 # GL/glext.h:2839
GL_MAP1_VERTEX_ATTRIB15_4_NV = 34415 # GL/glext.h:2840
GL_MAP2_VERTEX_ATTRIB0_4_NV = 34416 # GL/glext.h:2841
GL_MAP2_VERTEX_ATTRIB1_4_NV = 34417 # GL/glext.h:2842
GL_MAP2_VERTEX_ATTRIB2_4_NV = 34418 # GL/glext.h:2843
GL_MAP2_VERTEX_ATTRIB3_4_NV = 34419 # GL/glext.h:2844
GL_MAP2_VERTEX_ATTRIB4_4_NV = 34420 # GL/glext.h:2845
GL_MAP2_VERTEX_ATTRIB5_4_NV = 34421 # GL/glext.h:2846
GL_MAP2_VERTEX_ATTRIB6_4_NV = 34422 # GL/glext.h:2847
GL_MAP2_VERTEX_ATTRIB7_4_NV = 34423 # GL/glext.h:2848
GL_MAP2_VERTEX_ATTRIB8_4_NV = 34424 # GL/glext.h:2849
GL_MAP2_VERTEX_ATTRIB9_4_NV = 34425 # GL/glext.h:2850
GL_MAP2_VERTEX_ATTRIB10_4_NV = 34426 # GL/glext.h:2851
GL_MAP2_VERTEX_ATTRIB11_4_NV = 34427 # GL/glext.h:2852
GL_MAP2_VERTEX_ATTRIB12_4_NV = 34428 # GL/glext.h:2853
GL_MAP2_VERTEX_ATTRIB13_4_NV = 34429 # GL/glext.h:2854
GL_MAP2_VERTEX_ATTRIB14_4_NV = 34430 # GL/glext.h:2855
GL_MAP2_VERTEX_ATTRIB15_4_NV = 34431 # GL/glext.h:2856
# SGIX_texture_coordinate_clamp (GL/glext.h:2859)
GL_TEXTURE_MAX_CLAMP_S_SGIX = 33641 # GL/glext.h:2860
GL_TEXTURE_MAX_CLAMP_T_SGIX = 33642 # GL/glext.h:2861
GL_TEXTURE_MAX_CLAMP_R_SGIX = 33643 # GL/glext.h:2862
# SGIX_scalebias_hint (GL/glext.h:2865)
GL_SCALEBIAS_HINT_SGIX = 33570 # GL/glext.h:2866
# OML_interlace (GL/glext.h:2869)
GL_INTERLACE_OML = 35200 # GL/glext.h:2870
GL_INTERLACE_READ_OML = 35201 # GL/glext.h:2871
# OML_subsample (GL/glext.h:2874)
GL_FORMAT_SUBSAMPLE_24_24_OML = 35202 # GL/glext.h:2875
GL_FORMAT_SUBSAMPLE_244_244_OML = 35203 # GL/glext.h:2876
# OML_resample (GL/glext.h:2879)
GL_PACK_RESAMPLE_OML = 35204 # GL/glext.h:2880
GL_UNPACK_RESAMPLE_OML = 35205 # GL/glext.h:2881
GL_RESAMPLE_REPLICATE_OML = 35206 # GL/glext.h:2882
GL_RESAMPLE_ZERO_FILL_OML = 35207 # GL/glext.h:2883
GL_RESAMPLE_AVERAGE_OML = 35208 # GL/glext.h:2884
GL_RESAMPLE_DECIMATE_OML = 35209 # GL/glext.h:2885
# NV_copy_depth_to_color (GL/glext.h:2888)
GL_DEPTH_STENCIL_TO_RGBA_NV = 34926 # GL/glext.h:2889
GL_DEPTH_STENCIL_TO_BGRA_NV = 34927 # GL/glext.h:2890
# ATI_envmap_bumpmap (GL/glext.h:2893)
GL_BUMP_ROT_MATRIX_ATI = 34677 # GL/glext.h:2894
GL_BUMP_ROT_MATRIX_SIZE_ATI = 34678 # GL/glext.h:2895
GL_BUMP_NUM_TEX_UNITS_ATI = 34679 # GL/glext.h:2896
GL_BUMP_TEX_UNITS_ATI = 34680 # GL/glext.h:2897
GL_DUDV_ATI = 34681 # GL/glext.h:2898
GL_DU8DV8_ATI = 34682 # GL/glext.h:2899
GL_BUMP_ENVMAP_ATI = 34683 # GL/glext.h:2900
GL_BUMP_TARGET_ATI = 34684 # GL/glext.h:2901
# ATI_fragment_shader (GL/glext.h:2904)
GL_FRAGMENT_SHADER_ATI = 35104 # GL/glext.h:2905
GL_REG_0_ATI = 35105 # GL/glext.h:2906
GL_REG_1_ATI = 35106 # GL/glext.h:2907
GL_REG_2_ATI = 35107 # GL/glext.h:2908
GL_REG_3_ATI = 35108 # GL/glext.h:2909
GL_REG_4_ATI = 35109 # GL/glext.h:2910
GL_REG_5_ATI = 35110 # GL/glext.h:2911
GL_REG_6_ATI = 35111 # GL/glext.h:2912
GL_REG_7_ATI = 35112 # GL/glext.h:2913
GL_REG_8_ATI = 35113 # GL/glext.h:2914
GL_REG_9_ATI = 35114 # GL/glext.h:2915
GL_REG_10_ATI = 35115 # GL/glext.h:2916
GL_REG_11_ATI = 35116 # GL/glext.h:2917
GL_REG_12_ATI = 35117 # GL/glext.h:2918
GL_REG_13_ATI = 35118 # GL/glext.h:2919
GL_REG_14_ATI = 35119 # GL/glext.h:2920
GL_REG_15_ATI = 35120 # GL/glext.h:2921
GL_REG_16_ATI = 35121 # GL/glext.h:2922
GL_REG_17_ATI = 35122 # GL/glext.h:2923
GL_REG_18_ATI = 35123 # GL/glext.h:2924
GL_REG_19_ATI = 35124 # GL/glext.h:2925
GL_REG_20_ATI = 35125 # GL/glext.h:2926
GL_REG_21_ATI = 35126 # GL/glext.h:2927
GL_REG_22_ATI = 35127 # GL/glext.h:2928
GL_REG_23_ATI = 35128 # GL/glext.h:2929
GL_REG_24_ATI = 35129 # GL/glext.h:2930
GL_REG_25_ATI = 35130 # GL/glext.h:2931
GL_REG_26_ATI = 35131 # GL/glext.h:2932
GL_REG_27_ATI = 35132 # GL/glext.h:2933
GL_REG_28_ATI = 35133 # GL/glext.h:2934
GL_REG_29_ATI = 35134 # GL/glext.h:2935
GL_REG_30_ATI = 35135 # GL/glext.h:2936
GL_REG_31_ATI = 35136 # GL/glext.h:2937
GL_CON_0_ATI = 35137 # GL/glext.h:2938
GL_CON_1_ATI = 35138 # GL/glext.h:2939
GL_CON_2_ATI = 35139 # GL/glext.h:2940
GL_CON_3_ATI = 35140 # GL/glext.h:2941
GL_CON_4_ATI = 35141 # GL/glext.h:2942
GL_CON_5_ATI = 35142 # GL/glext.h:2943
GL_CON_6_ATI = 35143 # GL/glext.h:2944
GL_CON_7_ATI = 35144 # GL/glext.h:2945
GL_CON_8_ATI = 35145 # GL/glext.h:2946
GL_CON_9_ATI = 35146 # GL/glext.h:2947
GL_CON_10_ATI = 35147 # GL/glext.h:2948
GL_CON_11_ATI = 35148 # GL/glext.h:2949
GL_CON_12_ATI = 35149 # GL/glext.h:2950
GL_CON_13_ATI = 35150 # GL/glext.h:2951
GL_CON_14_ATI = 35151 # GL/glext.h:2952
GL_CON_15_ATI = 35152 # GL/glext.h:2953
GL_CON_16_ATI = 35153 # GL/glext.h:2954
GL_CON_17_ATI = 35154 # GL/glext.h:2955
GL_CON_18_ATI = 35155 # GL/glext.h:2956
GL_CON_19_ATI = 35156 # GL/glext.h:2957
GL_CON_20_ATI = 35157 # GL/glext.h:2958
GL_CON_21_ATI = 35158 # GL/glext.h:2959
GL_CON_22_ATI = 35159 # GL/glext.h:2960
GL_CON_23_ATI = 35160 # GL/glext.h:2961
GL_CON_24_ATI = 35161 # GL/glext.h:2962
GL_CON_25_ATI = 35162 # GL/glext.h:2963
GL_CON_26_ATI = 35163 # GL/glext.h:2964
GL_CON_27_ATI = 35164 # GL/glext.h:2965
GL_CON_28_ATI = 35165 # GL/glext.h:2966
GL_CON_29_ATI = 35166 # GL/glext.h:2967
GL_CON_30_ATI = 35167 # GL/glext.h:2968
GL_CON_31_ATI = 35168 # GL/glext.h:2969
GL_MOV_ATI = 35169 # GL/glext.h:2970
GL_ADD_ATI = 35171 # GL/glext.h:2971
GL_MUL_ATI = 35172 # GL/glext.h:2972
GL_SUB_ATI = 35173 # GL/glext.h:2973
GL_DOT3_ATI = 35174 # GL/glext.h:2974
GL_DOT4_ATI = 35175 # GL/glext.h:2975
GL_MAD_ATI = 35176 # GL/glext.h:2976
GL_LERP_ATI = 35177 # GL/glext.h:2977
GL_CND_ATI = 35178 # GL/glext.h:2978
GL_CND0_ATI = 35179 # GL/glext.h:2979
GL_DOT2_ADD_ATI = 35180 # GL/glext.h:2980
GL_SECONDARY_INTERPOLATOR_ATI = 35181 # GL/glext.h:2981
GL_NUM_FRAGMENT_REGISTERS_ATI = 35182 # GL/glext.h:2982
GL_NUM_FRAGMENT_CONSTANTS_ATI = 35183 # GL/glext.h:2983
GL_NUM_PASSES_ATI = 35184 # GL/glext.h:2984
GL_NUM_INSTRUCTIONS_PER_PASS_ATI = 35185 # GL/glext.h:2985
GL_NUM_INSTRUCTIONS_TOTAL_ATI = 35186 # GL/glext.h:2986
GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 35187 # GL/glext.h:2987
GL_NUM_LOOPBACK_COMPONENTS_ATI = 35188 # GL/glext.h:2988
GL_COLOR_ALPHA_PAIRING_ATI = 35189 # GL/glext.h:2989
GL_SWIZZLE_STR_ATI = 35190 # GL/glext.h:2990
GL_SWIZZLE_STQ_ATI = 35191 # GL/glext.h:2991
GL_SWIZZLE_STR_DR_ATI = 35192 # GL/glext.h:2992
GL_SWIZZLE_STQ_DQ_ATI = 35193 # GL/glext.h:2993
GL_SWIZZLE_STRQ_ATI = 35194 # GL/glext.h:2994
GL_SWIZZLE_STRQ_DQ_ATI = 35195 # GL/glext.h:2995
GL_RED_BIT_ATI = 1 # GL/glext.h:2996
GL_GREEN_BIT_ATI = 2 # GL/glext.h:2997
GL_BLUE_BIT_ATI = 4 # GL/glext.h:2998
GL_2X_BIT_ATI = 1 # GL/glext.h:2999
GL_4X_BIT_ATI = 2 # GL/glext.h:3000
GL_8X_BIT_ATI = 4 # GL/glext.h:3001
GL_HALF_BIT_ATI = 8 # GL/glext.h:3002
GL_QUARTER_BIT_ATI = 16 # GL/glext.h:3003
GL_EIGHTH_BIT_ATI = 32 # GL/glext.h:3004
GL_SATURATE_BIT_ATI = 64 # GL/glext.h:3005
GL_COMP_BIT_ATI = 2 # GL/glext.h:3006
GL_NEGATE_BIT_ATI = 4 # GL/glext.h:3007
GL_BIAS_BIT_ATI = 8 # GL/glext.h:3008
# ATI_pn_triangles (GL/glext.h:3011)
GL_PN_TRIANGLES_ATI = 34800 # GL/glext.h:3012
GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34801 # GL/glext.h:3013
GL_PN_TRIANGLES_POINT_MODE_ATI = 34802 # GL/glext.h:3014
GL_PN_TRIANGLES_NORMAL_MODE_ATI = 34803 # GL/glext.h:3015
GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34804 # GL/glext.h:3016
GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 34805 # GL/glext.h:3017
GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 34806 # GL/glext.h:3018
GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 34807 # GL/glext.h:3019
GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 34808 # GL/glext.h:3020
# ATI_vertex_array_object (GL/glext.h:3023)
GL_STATIC_ATI = 34656 # GL/glext.h:3024
GL_DYNAMIC_ATI = 34657 # GL/glext.h:3025
GL_PRESERVE_ATI = 34658 # GL/glext.h:3026
GL_DISCARD_ATI = 34659 # GL/glext.h:3027
GL_OBJECT_BUFFER_SIZE_ATI = 34660 # GL/glext.h:3028
GL_OBJECT_BUFFER_USAGE_ATI = 34661 # GL/glext.h:3029
GL_ARRAY_OBJECT_BUFFER_ATI = 34662 # GL/glext.h:3030
GL_ARRAY_OBJECT_OFFSET_ATI = 34663 # GL/glext.h:3031
# EXT_vertex_shader (GL/glext.h:3034)
GL_VERTEX_SHADER_EXT = 34688 # GL/glext.h:3035
GL_VERTEX_SHADER_BINDING_EXT = 34689 # GL/glext.h:3036
GL_OP_INDEX_EXT = 34690 # GL/glext.h:3037
GL_OP_NEGATE_EXT = 34691 # GL/glext.h:3038
GL_OP_DOT3_EXT = 34692 # GL/glext.h:3039
GL_OP_DOT4_EXT = 34693 # GL/glext.h:3040
GL_OP_MUL_EXT = 34694 # GL/glext.h:3041
GL_OP_ADD_EXT = 34695 # GL/glext.h:3042
GL_OP_MADD_EXT = 34696 # GL/glext.h:3043
GL_OP_FRAC_EXT = 34697 # GL/glext.h:3044
GL_OP_MAX_EXT = 34698 # GL/glext.h:3045
GL_OP_MIN_EXT = 34699 # GL/glext.h:3046
GL_OP_SET_GE_EXT = 34700 # GL/glext.h:3047
GL_OP_SET_LT_EXT = 34701 # GL/glext.h:3048
GL_OP_CLAMP_EXT = 34702 # GL/glext.h:3049
GL_OP_FLOOR_EXT = 34703 # GL/glext.h:3050
GL_OP_ROUND_EXT = 34704 # GL/glext.h:3051
GL_OP_EXP_BASE_2_EXT = 34705 # GL/glext.h:3052
GL_OP_LOG_BASE_2_EXT = 34706 # GL/glext.h:3053
GL_OP_POWER_EXT = 34707 # GL/glext.h:3054
GL_OP_RECIP_EXT = 34708 # GL/glext.h:3055
GL_OP_RECIP_SQRT_EXT = 34709 # GL/glext.h:3056
GL_OP_SUB_EXT = 34710 # GL/glext.h:3057
GL_OP_CROSS_PRODUCT_EXT = 34711 # GL/glext.h:3058
GL_OP_MULTIPLY_MATRIX_EXT = 34712 # GL/glext.h:3059
GL_OP_MOV_EXT = 34713 # GL/glext.h:3060
GL_OUTPUT_VERTEX_EXT = 34714 # GL/glext.h:3061
GL_OUTPUT_COLOR0_EXT = 34715 # GL/glext.h:3062
GL_OUTPUT_COLOR1_EXT = 34716 # GL/glext.h:3063
GL_OUTPUT_TEXTURE_COORD0_EXT = 34717 # GL/glext.h:3064
GL_OUTPUT_TEXTURE_COORD1_EXT = 34718 # GL/glext.h:3065
GL_OUTPUT_TEXTURE_COORD2_EXT = 34719 # GL/glext.h:3066
GL_OUTPUT_TEXTURE_COORD3_EXT = 34720 # GL/glext.h:3067
GL_OUTPUT_TEXTURE_COORD4_EXT = 34721 # GL/glext.h:3068
GL_OUTPUT_TEXTURE_COORD5_EXT = 34722 # GL/glext.h:3069
GL_OUTPUT_TEXTURE_COORD6_EXT = 34723 # GL/glext.h:3070
GL_OUTPUT_TEXTURE_COORD7_EXT = 34724 # GL/glext.h:3071
GL_OUTPUT_TEXTURE_COORD8_EXT = 34725 # GL/glext.h:3072
GL_OUTPUT_TEXTURE_COORD9_EXT = 34726 # GL/glext.h:3073
GL_OUTPUT_TEXTURE_COORD10_EXT = 34727 # GL/glext.h:3074
GL_OUTPUT_TEXTURE_COORD11_EXT = 34728 # GL/glext.h:3075
GL_OUTPUT_TEXTURE_COORD12_EXT = 34729 # GL/glext.h:3076
GL_OUTPUT_TEXTURE_COORD13_EXT = 34730 # GL/glext.h:3077
GL_OUTPUT_TEXTURE_COORD14_EXT = 34731 # GL/glext.h:3078
GL_OUTPUT_TEXTURE_COORD15_EXT = 34732 # GL/glext.h:3079
GL_OUTPUT_TEXTURE_COORD16_EXT = 34733 # GL/glext.h:3080
GL_OUTPUT_TEXTURE_COORD17_EXT = 34734 # GL/glext.h:3081
GL_OUTPUT_TEXTURE_COORD18_EXT = 34735 # GL/glext.h:3082
GL_OUTPUT_TEXTURE_COORD19_EXT = 34736 # GL/glext.h:3083
GL_OUTPUT_TEXTURE_COORD20_EXT = 34737 # GL/glext.h:3084
GL_OUTPUT_TEXTURE_COORD21_EXT = 34738 # GL/glext.h:3085
GL_OUTPUT_TEXTURE_COORD22_EXT = 34739 # GL/glext.h:3086
GL_OUTPUT_TEXTURE_COORD23_EXT = 34740 # GL/glext.h:3087
GL_OUTPUT_TEXTURE_COORD24_EXT = 34741 # GL/glext.h:3088
GL_OUTPUT_TEXTURE_COORD25_EXT = 34742 # GL/glext.h:3089
GL_OUTPUT_TEXTURE_COORD26_EXT = 34743 # GL/glext.h:3090
GL_OUTPUT_TEXTURE_COORD27_EXT = 34744 # GL/glext.h:3091
GL_OUTPUT_TEXTURE_COORD28_EXT = 34745 # GL/glext.h:3092
GL_OUTPUT_TEXTURE_COORD29_EXT = 34746 # GL/glext.h:3093
GL_OUTPUT_TEXTURE_COORD30_EXT = 34747 # GL/glext.h:3094
GL_OUTPUT_TEXTURE_COORD31_EXT = 34748 # GL/glext.h:3095
GL_OUTPUT_FOG_EXT = 34749 # GL/glext.h:3096
GL_SCALAR_EXT = 34750 # GL/glext.h:3097
GL_VECTOR_EXT = 34751 # GL/glext.h:3098
GL_MATRIX_EXT = 34752 # GL/glext.h:3099
GL_VARIANT_EXT = 34753 # GL/glext.h:3100
GL_INVARIANT_EXT = 34754 # GL/glext.h:3101
GL_LOCAL_CONSTANT_EXT = 34755 # GL/glext.h:3102
GL_LOCAL_EXT = 34756 # GL/glext.h:3103
GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 34757 # GL/glext.h:3104
GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 34758 # GL/glext.h:3105
GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 34759 # GL/glext.h:3106
GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34760 # GL/glext.h:3107
GL_MAX_VERTEX_SHADER_LOCALS_EXT = 34761 # GL/glext.h:3108
GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 34762 # GL/glext.h:3109
GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 34763 # GL/glext.h:3110
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34764 # GL/glext.h:3111
GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 34765 # GL/glext.h:3112
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 34766 # GL/glext.h:3113
GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 34767 # GL/glext.h:3114
GL_VERTEX_SHADER_VARIANTS_EXT = 34768 # GL/glext.h:3115
GL_VERTEX_SHADER_INVARIANTS_EXT = 34769 # GL/glext.h:3116
GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34770 # GL/glext.h:3117
GL_VERTEX_SHADER_LOCALS_EXT = 34771 # GL/glext.h:3118
GL_VERTEX_SHADER_OPTIMIZED_EXT = 34772 # GL/glext.h:3119
GL_X_EXT = 34773 # GL/glext.h:3120
GL_Y_EXT = 34774 # GL/glext.h:3121
GL_Z_EXT = 34775 # GL/glext.h:3122
GL_W_EXT = 34776 # GL/glext.h:3123
GL_NEGATIVE_X_EXT = 34777 # GL/glext.h:3124
GL_NEGATIVE_Y_EXT = 34778 # GL/glext.h:3125
GL_NEGATIVE_Z_EXT = 34779 # GL/glext.h:3126
GL_NEGATIVE_W_EXT = 34780 # GL/glext.h:3127
GL_ZERO_EXT = 34781 # GL/glext.h:3128
GL_ONE_EXT = 34782 # GL/glext.h:3129
GL_NEGATIVE_ONE_EXT = 34783 # GL/glext.h:3130
GL_NORMALIZED_RANGE_EXT = 34784 # GL/glext.h:3131
GL_FULL_RANGE_EXT = 34785 # GL/glext.h:3132
GL_CURRENT_VERTEX_EXT = 34786 # GL/glext.h:3133
GL_MVP_MATRIX_EXT = 34787 # GL/glext.h:3134
GL_VARIANT_VALUE_EXT = 34788 # GL/glext.h:3135
GL_VARIANT_DATATYPE_EXT = 34789 # GL/glext.h:3136
GL_VARIANT_ARRAY_STRIDE_EXT = 34790 # GL/glext.h:3137
GL_VARIANT_ARRAY_TYPE_EXT = 34791 # GL/glext.h:3138
GL_VARIANT_ARRAY_EXT = 34792 # GL/glext.h:3139
GL_VARIANT_ARRAY_POINTER_EXT = 34793 # GL/glext.h:3140
GL_INVARIANT_VALUE_EXT = 34794 # GL/glext.h:3141
GL_INVARIANT_DATATYPE_EXT = 34795 # GL/glext.h:3142
GL_LOCAL_CONSTANT_VALUE_EXT = 34796 # GL/glext.h:3143
GL_LOCAL_CONSTANT_DATATYPE_EXT = 34797 # GL/glext.h:3144
# ATI_vertex_streams (GL/glext.h:3147)
GL_MAX_VERTEX_STREAMS_ATI = 34667 # GL/glext.h:3148
GL_VERTEX_STREAM0_ATI = 34668 # GL/glext.h:3149
GL_VERTEX_STREAM1_ATI = 34669 # GL/glext.h:3150
GL_VERTEX_STREAM2_ATI = 34670 # GL/glext.h:3151
GL_VERTEX_STREAM3_ATI = 34671 # GL/glext.h:3152
GL_VERTEX_STREAM4_ATI = 34672 # GL/glext.h:3153
GL_VERTEX_STREAM5_ATI = 34673 # GL/glext.h:3154
GL_VERTEX_STREAM6_ATI = 34674 # GL/glext.h:3155
GL_VERTEX_STREAM7_ATI = 34675 # GL/glext.h:3156
GL_VERTEX_SOURCE_ATI = 34676 # GL/glext.h:3157
# ATI_element_array (GL/glext.h:3160)
GL_ELEMENT_ARRAY_ATI = 34664 # GL/glext.h:3161
GL_ELEMENT_ARRAY_TYPE_ATI = 34665 # GL/glext.h:3162
GL_ELEMENT_ARRAY_POINTER_ATI = 34666 # GL/glext.h:3163
# SUN_mesh_array (GL/glext.h:3166)
GL_QUAD_MESH_SUN = 34324 # GL/glext.h:3167
GL_TRIANGLE_MESH_SUN = 34325 # GL/glext.h:3168
# SUN_slice_accum (GL/glext.h:3171)
GL_SLICE_ACCUM_SUN = 34252 # GL/glext.h:3172
# NV_multisample_filter_hint (GL/glext.h:3175)
GL_MULTISAMPLE_FILTER_HINT_NV = 34100 # GL/glext.h:3176
# NV_depth_clamp (GL/glext.h:3179)
GL_DEPTH_CLAMP_NV = 34383 # GL/glext.h:3180
# NV_occlusion_query (GL/glext.h:3183)
GL_PIXEL_COUNTER_BITS_NV = 34916 # GL/glext.h:3184
GL_CURRENT_OCCLUSION_QUERY_ID_NV = 34917 # GL/glext.h:3185
GL_PIXEL_COUNT_NV = 34918 # GL/glext.h:3186
GL_PIXEL_COUNT_AVAILABLE_NV = 34919 # GL/glext.h:3187
# NV_point_sprite (GL/glext.h:3190)
GL_POINT_SPRITE_NV = 34913 # GL/glext.h:3191
GL_COORD_REPLACE_NV = 34914 # GL/glext.h:3192
GL_POINT_SPRITE_R_MODE_NV = 34915 # GL/glext.h:3193
# NV_texture_shader3 (GL/glext.h:3196)
GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 34896 # GL/glext.h:3197
GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 34897 # GL/glext.h:3198
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 34898 # GL/glext.h:3199
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 34899 # GL/glext.h:3200
GL_OFFSET_HILO_TEXTURE_2D_NV = 34900 # GL/glext.h:3201
GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 34901 # GL/glext.h:3202
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 34902 # GL/glext.h:3203
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 34903 # GL/glext.h:3204
GL_DEPENDENT_HILO_TEXTURE_2D_NV = 34904 # GL/glext.h:3205
GL_DEPENDENT_RGB_TEXTURE_3D_NV = 34905 # GL/glext.h:3206
GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 34906 # GL/glext.h:3207
GL_DOT_PRODUCT_PASS_THROUGH_NV = 34907 # GL/glext.h:3208
GL_DOT_PRODUCT_TEXTURE_1D_NV = 34908 # GL/glext.h:3209
GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 34909 # GL/glext.h:3210
GL_HILO8_NV = 34910 # GL/glext.h:3211
GL_SIGNED_HILO8_NV = 34911 # GL/glext.h:3212
GL_FORCE_BLUE_TO_ONE_NV = 34912 # GL/glext.h:3213
# NV_vertex_program1_1 (GL/glext.h:3216)
# EXT_shadow_funcs (GL/glext.h:3219)
# EXT_stencil_two_side (GL/glext.h:3222)
GL_STENCIL_TEST_TWO_SIDE_EXT = 35088 # GL/glext.h:3223
GL_ACTIVE_STENCIL_FACE_EXT = 35089 # GL/glext.h:3224
# ATI_text_fragment_shader (GL/glext.h:3227)
GL_TEXT_FRAGMENT_SHADER_ATI = 33280 # GL/glext.h:3228
# APPLE_client_storage (GL/glext.h:3231)
GL_UNPACK_CLIENT_STORAGE_APPLE = 34226 # GL/glext.h:3232
# APPLE_element_array (GL/glext.h:3235)
GL_ELEMENT_ARRAY_APPLE = 34664 # GL/glext.h:3236
GL_ELEMENT_ARRAY_TYPE_APPLE = 34665 # GL/glext.h:3237
GL_ELEMENT_ARRAY_POINTER_APPLE = 34666 # GL/glext.h:3238
# APPLE_fence (GL/glext.h:3241)
GL_DRAW_PIXELS_APPLE = 35338 # GL/glext.h:3242
GL_FENCE_APPLE = 35339 # GL/glext.h:3243
# APPLE_vertex_array_object (GL/glext.h:3246)
GL_VERTEX_ARRAY_BINDING_APPLE = 34229 # GL/glext.h:3247
# APPLE_vertex_array_range (GL/glext.h:3250)
GL_VERTEX_ARRAY_RANGE_APPLE = 34077 # GL/glext.h:3251
GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 34078 # GL/glext.h:3252
GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = 34079 # GL/glext.h:3253
GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = 34081 # GL/glext.h:3254
GL_STORAGE_CACHED_APPLE = 34238 # GL/glext.h:3255
GL_STORAGE_SHARED_APPLE = 34239 # GL/glext.h:3256
# APPLE_ycbcr_422 (GL/glext.h:3259)
GL_YCBCR_422_APPLE = 34233 # GL/glext.h:3260
GL_UNSIGNED_SHORT_8_8_APPLE = 34234 # GL/glext.h:3261
GL_UNSIGNED_SHORT_8_8_REV_APPLE = 34235 # GL/glext.h:3262
# S3_s3tc (GL/glext.h:3265)
GL_RGB_S3TC = 33696 # GL/glext.h:3266
GL_RGB4_S3TC = 33697 # GL/glext.h:3267
GL_RGBA_S3TC = 33698 # GL/glext.h:3268
GL_RGBA4_S3TC = 33699 # GL/glext.h:3269
# ATI_draw_buffers (GL/glext.h:3272)
GL_MAX_DRAW_BUFFERS_ATI = 34852 # GL/glext.h:3273
GL_DRAW_BUFFER0_ATI = 34853 # GL/glext.h:3274
GL_DRAW_BUFFER1_ATI = 34854 # GL/glext.h:3275
GL_DRAW_BUFFER2_ATI = 34855 # GL/glext.h:3276
GL_DRAW_BUFFER3_ATI = 34856 # GL/glext.h:3277
GL_DRAW_BUFFER4_ATI = 34857 # GL/glext.h:3278
GL_DRAW_BUFFER5_ATI = 34858 # GL/glext.h:3279
GL_DRAW_BUFFER6_ATI = 34859 # GL/glext.h:3280
GL_DRAW_BUFFER7_ATI = 34860 # GL/glext.h:3281
GL_DRAW_BUFFER8_ATI = 34861 # GL/glext.h:3282
GL_DRAW_BUFFER9_ATI = 34862 # GL/glext.h:3283
GL_DRAW_BUFFER10_ATI = 34863 # GL/glext.h:3284
GL_DRAW_BUFFER11_ATI = 34864 # GL/glext.h:3285
GL_DRAW_BUFFER12_ATI = 34865 # GL/glext.h:3286
GL_DRAW_BUFFER13_ATI = 34866 # GL/glext.h:3287
GL_DRAW_BUFFER14_ATI = 34867 # GL/glext.h:3288
GL_DRAW_BUFFER15_ATI = 34868 # GL/glext.h:3289
# ATI_pixel_format_float (GL/glext.h:3292)
GL_TYPE_RGBA_FLOAT_ATI = 34848 # GL/glext.h:3293
GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 34869 # GL/glext.h:3294
# ATI_texture_env_combine3 (GL/glext.h:3297)
GL_MODULATE_ADD_ATI = 34628 # GL/glext.h:3298
GL_MODULATE_SIGNED_ADD_ATI = 34629 # GL/glext.h:3299
GL_MODULATE_SUBTRACT_ATI = 34630 # GL/glext.h:3300
# ATI_texture_float (GL/glext.h:3303)
GL_RGBA_FLOAT32_ATI = 34836 # GL/glext.h:3304
GL_RGB_FLOAT32_ATI = 34837 # GL/glext.h:3305
GL_ALPHA_FLOAT32_ATI = 34838 # GL/glext.h:3306
GL_INTENSITY_FLOAT32_ATI = 34839 # GL/glext.h:3307
GL_LUMINANCE_FLOAT32_ATI = 34840 # GL/glext.h:3308
GL_LUMINANCE_ALPHA_FLOAT32_ATI = 34841 # GL/glext.h:3309
GL_RGBA_FLOAT16_ATI = 34842 # GL/glext.h:3310
GL_RGB_FLOAT16_ATI = 34843 # GL/glext.h:3311
GL_ALPHA_FLOAT16_ATI = 34844 # GL/glext.h:3312
GL_INTENSITY_FLOAT16_ATI = 34845 # GL/glext.h:3313
GL_LUMINANCE_FLOAT16_ATI = 34846 # GL/glext.h:3314
GL_LUMINANCE_ALPHA_FLOAT16_ATI = 34847 # GL/glext.h:3315
# NV_float_buffer (GL/glext.h:3318)
GL_FLOAT_R_NV = 34944 # GL/glext.h:3319
GL_FLOAT_RG_NV = 34945 # GL/glext.h:3320
GL_FLOAT_RGB_NV = 34946 # GL/glext.h:3321
GL_FLOAT_RGBA_NV = 34947 # GL/glext.h:3322
GL_FLOAT_R16_NV = 34948 # GL/glext.h:3323
GL_FLOAT_R32_NV = 34949 # GL/glext.h:3324
GL_FLOAT_RG16_NV = 34950 # GL/glext.h:3325
GL_FLOAT_RG32_NV = 34951 # GL/glext.h:3326
GL_FLOAT_RGB16_NV = 34952 # GL/glext.h:3327
GL_FLOAT_RGB32_NV = 34953 # GL/glext.h:3328
GL_FLOAT_RGBA16_NV = 34954 # GL/glext.h:3329
GL_FLOAT_RGBA32_NV = 34955 # GL/glext.h:3330
GL_TEXTURE_FLOAT_COMPONENTS_NV = 34956 # GL/glext.h:3331
GL_FLOAT_CLEAR_COLOR_VALUE_NV = 34957 # GL/glext.h:3332
GL_FLOAT_RGBA_MODE_NV = 34958 # GL/glext.h:3333
# NV_fragment_program (GL/glext.h:3336)
GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 34920 # GL/glext.h:3337
GL_FRAGMENT_PROGRAM_NV = 34928 # GL/glext.h:3338
GL_MAX_TEXTURE_COORDS_NV = 34929 # GL/glext.h:3339
GL_MAX_TEXTURE_IMAGE_UNITS_NV = 34930 # GL/glext.h:3340
GL_FRAGMENT_PROGRAM_BINDING_NV = 34931 # GL/glext.h:3341
GL_PROGRAM_ERROR_STRING_NV = 34932 # GL/glext.h:3342
# NV_half_float (GL/glext.h:3345)
GL_HALF_FLOAT_NV = 5131 # GL/glext.h:3346
# NV_pixel_data_range (GL/glext.h:3349)
GL_WRITE_PIXEL_DATA_RANGE_NV = 34936 # GL/glext.h:3350
GL_READ_PIXEL_DATA_RANGE_NV = 34937 # GL/glext.h:3351
GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 34938 # GL/glext.h:3352
GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = 34939 # GL/glext.h:3353
GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 34940 # GL/glext.h:3354
GL_READ_PIXEL_DATA_RANGE_POINTER_NV = 34941 # GL/glext.h:3355
# NV_primitive_restart (GL/glext.h:3358)
GL_PRIMITIVE_RESTART_NV = 34136 # GL/glext.h:3359
GL_PRIMITIVE_RESTART_INDEX_NV = 34137 # GL/glext.h:3360
# NV_texture_expand_normal (GL/glext.h:3363)
GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = 34959 # GL/glext.h:3364
# NV_vertex_program2 (GL/glext.h:3367)
# ATI_map_object_buffer (GL/glext.h:3370)
# ATI_separate_stencil (GL/glext.h:3373)
GL_STENCIL_BACK_FUNC_ATI = 34816 # GL/glext.h:3374
GL_STENCIL_BACK_FAIL_ATI = 34817 # GL/glext.h:3375
GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 34818 # GL/glext.h:3376
GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 34819 # GL/glext.h:3377
# ATI_vertex_attrib_array_object (GL/glext.h:3380)
# OES_read_format (GL/glext.h:3383)
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 35738 # GL/glext.h:3384
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 35739 # GL/glext.h:3385
# EXT_depth_bounds_test (GL/glext.h:3388)
GL_DEPTH_BOUNDS_TEST_EXT = 34960 # GL/glext.h:3389
GL_DEPTH_BOUNDS_EXT = 34961 # GL/glext.h:3390
# EXT_texture_mirror_clamp (GL/glext.h:3393)
GL_MIRROR_CLAMP_EXT = 34626 # GL/glext.h:3394
GL_MIRROR_CLAMP_TO_EDGE_EXT = 34627 # GL/glext.h:3395
GL_MIRROR_CLAMP_TO_BORDER_EXT = 35090 # GL/glext.h:3396
# EXT_blend_equation_separate (GL/glext.h:3399)
GL_BLEND_EQUATION_RGB_EXT = 32777 # GL/glext.h:3400
GL_BLEND_EQUATION_ALPHA_EXT = 34877 # GL/glext.h:3401
# MESA_pack_invert (GL/glext.h:3404)
GL_PACK_INVERT_MESA = 34648 # GL/glext.h:3405
# MESA_ycbcr_texture (GL/glext.h:3408)
GL_UNSIGNED_SHORT_8_8_MESA = 34234 # GL/glext.h:3409
GL_UNSIGNED_SHORT_8_8_REV_MESA = 34235 # GL/glext.h:3410
GL_YCBCR_MESA = 34647 # GL/glext.h:3411
# EXT_pixel_buffer_object (GL/glext.h:3414)
GL_PIXEL_PACK_BUFFER_EXT = 35051 # GL/glext.h:3415
GL_PIXEL_UNPACK_BUFFER_EXT = 35052 # GL/glext.h:3416
GL_PIXEL_PACK_BUFFER_BINDING_EXT = 35053 # GL/glext.h:3417
GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = 35055 # GL/glext.h:3418
# NV_fragment_program_option (GL/glext.h:3421)
# NV_fragment_program2 (GL/glext.h:3424)
GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 35060 # GL/glext.h:3425
GL_MAX_PROGRAM_CALL_DEPTH_NV = 35061 # GL/glext.h:3426
GL_MAX_PROGRAM_IF_DEPTH_NV = 35062 # GL/glext.h:3427
GL_MAX_PROGRAM_LOOP_DEPTH_NV = 35063 # GL/glext.h:3428
GL_MAX_PROGRAM_LOOP_COUNT_NV = 35064 # GL/glext.h:3429
# NV_vertex_program2_option (GL/glext.h:3432)
# NV_vertex_program3 (GL/glext.h:3437)
# EXT_framebuffer_object (GL/glext.h:3441)
GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 1286 # GL/glext.h:3442
GL_MAX_RENDERBUFFER_SIZE_EXT = 34024 # GL/glext.h:3443
GL_FRAMEBUFFER_BINDING_EXT = 36006 # GL/glext.h:3444
GL_RENDERBUFFER_BINDING_EXT = 36007 # GL/glext.h:3445
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 36048 # GL/glext.h:3446
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 36049 # GL/glext.h:3447
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 36050 # GL/glext.h:3448
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 36051 # GL/glext.h:3449
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 36052 # GL/glext.h:3450
GL_FRAMEBUFFER_COMPLETE_EXT = 36053 # GL/glext.h:3451
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 36054 # GL/glext.h:3452
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 36055 # GL/glext.h:3453
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 36056 # GL/glext.h:3454
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 36057 # GL/glext.h:3455
GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 36058 # GL/glext.h:3456
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 36059 # GL/glext.h:3457
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 36060 # GL/glext.h:3458
GL_FRAMEBUFFER_UNSUPPORTED_EXT = 36061 # GL/glext.h:3459
GL_MAX_COLOR_ATTACHMENTS_EXT = 36063 # GL/glext.h:3460
GL_COLOR_ATTACHMENT0_EXT = 36064 # GL/glext.h:3461
GL_COLOR_ATTACHMENT1_EXT = 36065 # GL/glext.h:3462
GL_COLOR_ATTACHMENT2_EXT = 36066 # GL/glext.h:3463
GL_COLOR_ATTACHMENT3_EXT = 36067 # GL/glext.h:3464
GL_COLOR_ATTACHMENT4_EXT = 36068 # GL/glext.h:3465
GL_COLOR_ATTACHMENT5_EXT = 36069 # GL/glext.h:3466
GL_COLOR_ATTACHMENT6_EXT = 36070 # GL/glext.h:3467
GL_COLOR_ATTACHMENT7_EXT = 36071 # GL/glext.h:3468
GL_COLOR_ATTACHMENT8_EXT = 36072 # GL/glext.h:3469
GL_COLOR_ATTACHMENT9_EXT = 36073 # GL/glext.h:3470
GL_COLOR_ATTACHMENT10_EXT = 36074 # GL/glext.h:3471
GL_COLOR_ATTACHMENT11_EXT = 36075 # GL/glext.h:3472
GL_COLOR_ATTACHMENT12_EXT = 36076 # GL/glext.h:3473
GL_COLOR_ATTACHMENT13_EXT = 36077 # GL/glext.h:3474
GL_COLOR_ATTACHMENT14_EXT = 36078 # GL/glext.h:3475
GL_COLOR_ATTACHMENT15_EXT = 36079 # GL/glext.h:3476
GL_DEPTH_ATTACHMENT_EXT = 36096 # GL/glext.h:3477
GL_STENCIL_ATTACHMENT_EXT = 36128 # GL/glext.h:3478
GL_FRAMEBUFFER_EXT = 36160 # GL/glext.h:3479
GL_RENDERBUFFER_EXT = 36161 # GL/glext.h:3480
GL_RENDERBUFFER_WIDTH_EXT = 36162 # GL/glext.h:3481
GL_RENDERBUFFER_HEIGHT_EXT = 36163 # GL/glext.h:3482
GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 36164 # GL/glext.h:3483
GL_STENCIL_INDEX_EXT = 36165 # GL/glext.h:3484
GL_STENCIL_INDEX1_EXT = 36166 # GL/glext.h:3485
GL_STENCIL_INDEX4_EXT = 36167 # GL/glext.h:3486
GL_STENCIL_INDEX8_EXT = 36168 # GL/glext.h:3487
GL_STENCIL_INDEX16_EXT = 36169 # GL/glext.h:3488
GL_RENDERBUFFER_RED_SIZE_EXT = 36176 # GL/glext.h:3489
GL_RENDERBUFFER_GREEN_SIZE_EXT = 36177 # GL/glext.h:3490
GL_RENDERBUFFER_BLUE_SIZE_EXT = 36178 # GL/glext.h:3491
GL_RENDERBUFFER_ALPHA_SIZE_EXT = 36179 # GL/glext.h:3492
GL_RENDERBUFFER_DEPTH_SIZE_EXT = 36180 # GL/glext.h:3493
GL_RENDERBUFFER_STENCIL_SIZE_EXT = 36181 # GL/glext.h:3494
# GREMEDY_string_marker (GL/glext.h:3497)
# EXT_Cg_shader (GL/glext.h:3500)
GL_CG_VERTEX_SHADER_EXT = 35086 # GL/glext.h:3501
GL_CG_FRAGMENT_SHADER_EXT = 35087 # GL/glext.h:3502
# EXT_timer_query (GL/glext.h:3505)
GL_TIME_ELAPSED_EXT = 35007 # GL/glext.h:3506
# EXT_texture_buffer_object (GL/glext.h:3509)
GL_TEXTURE_BUFFER_EXT = 35882 # GL/glext.h:3510
GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 35883 # GL/glext.h:3511
GL_TEXTURE_BINDING_BUFFER_EXT = 35884 # GL/glext.h:3512
GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 35885 # GL/glext.h:3513
GL_TEXTURE_BUFFER_FORMAT_EXT = 35886 # GL/glext.h:3514
# EXT_gpu_shader4 (GL/glext.h:3517)
GL_SAMPLER_1D_ARRAY_EXT = 36288 # GL/glext.h:3518
GL_SAMPLER_2D_ARRAY_EXT = 36289 # GL/glext.h:3519
GL_SAMPLER_BUFFER_EXT = 36290 # GL/glext.h:3520
GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 36291 # GL/glext.h:3521
GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 36292 # GL/glext.h:3522
GL_SAMPLER_CUBE_SHADOW_EXT = 36293 # GL/glext.h:3523
GL_UNSIGNED_INT_VEC2_EXT = 36294 # GL/glext.h:3524
GL_UNSIGNED_INT_VEC3_EXT = 36295 # GL/glext.h:3525
GL_UNSIGNED_INT_VEC4_EXT = 36296 # GL/glext.h:3526
GL_INT_SAMPLER_1D_EXT = 36297 # GL/glext.h:3527
GL_INT_SAMPLER_2D_EXT = 36298 # GL/glext.h:3528
GL_INT_SAMPLER_3D_EXT = 36299 # GL/glext.h:3529
GL_INT_SAMPLER_CUBE_EXT = 36300 # GL/glext.h:3530
GL_INT_SAMPLER_2D_RECT_EXT = 36301 # GL/glext.h:3531
GL_INT_SAMPLER_1D_ARRAY_EXT = 36302 # GL/glext.h:3532
GL_INT_SAMPLER_2D_ARRAY_EXT = 36303 # GL/glext.h:3533
GL_INT_SAMPLER_BUFFER_EXT = 36304 # GL/glext.h:3534
GL_UNSIGNED_INT_SAMPLER_1D_EXT = 36305 # GL/glext.h:3535
GL_UNSIGNED_INT_SAMPLER_2D_EXT = 36306 # GL/glext.h:3536
GL_UNSIGNED_INT_SAMPLER_3D_EXT = 36307 # GL/glext.h:3537
GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 36308 # GL/glext.h:3538
GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 36309 # GL/glext.h:3539
GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 36310 # GL/glext.h:3540
GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 36311 # GL/glext.h:3541
GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 36312 # GL/glext.h:3542
GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 35069 # GL/glext.h:3543
# EXT_geometry_shader4 (GL/glext.h:3546)
GL_GEOMETRY_SHADER_EXT = 36313 # GL/glext.h:3547
GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 36317 # GL/glext.h:3548
GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 36318 # GL/glext.h:3549
GL_MAX_VARYING_COMPONENTS_EXT = 35659 # GL/glext.h:3550
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 36319 # GL/glext.h:3551
GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 36320 # GL/glext.h:3552
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 36321 # GL/glext.h:3553
GL_GEOMETRY_VERTICES_OUT_EXT = 36314 # GL/glext.h:3554
GL_GEOMETRY_INPUT_TYPE_EXT = 36315 # GL/glext.h:3555
GL_GEOMETRY_OUTPUT_TYPE_EXT = 36316 # GL/glext.h:3556
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 35881 # GL/glext.h:3557
GL_LINES_ADJACENCY_EXT = 10 # GL/glext.h:3558
GL_LINE_STRIP_ADJACENCY_EXT = 11 # GL/glext.h:3559
GL_TRIANGLES_ADJACENCY_EXT = 12 # GL/glext.h:3560
GL_TRIANGLE_STRIP_ADJACENCY_EXT = 13 # GL/glext.h:3561
GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 36263 # GL/glext.h:3562
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 36264 # GL/glext.h:3563
GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 36265 # GL/glext.h:3564
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 36052 # GL/glext.h:3565
GL_PROGRAM_POINT_SIZE_EXT = 34370 # GL/glext.h:3566
# EXT_bindable_uniform (GL/glext.h:3569)
GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 36322 # GL/glext.h:3570
GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 36323 # GL/glext.h:3571
GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 36324 # GL/glext.h:3572
GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 36333 # GL/glext.h:3573
GL_UNIFORM_BUFFER_EXT = 36334 # GL/glext.h:3574
GL_UNIFORM_BUFFER_BINDING_EXT = 36335 # GL/glext.h:3575
# EXT_framebuffer_sRGB (GL/glext.h:3578)
GL_FRAMEBUFFER_SRGB_EXT = 36281 # GL/glext.h:3579
GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 36282 # GL/glext.h:3580
# EXT_texture_shared_exponent (GL/glext.h:3583)
GL_RGB9_E5_EXT = 35901 # GL/glext.h:3584
GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 35902 # GL/glext.h:3585
GL_TEXTURE_SHARED_SIZE_EXT = 35903 # GL/glext.h:3586
# EXT_packed_float (GL/glext.h:3589)
GL_R11F_G11F_B10F_EXT = 35898 # GL/glext.h:3590
GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 35899 # GL/glext.h:3591
GL_RGBA_SIGNED_COMPONENTS_EXT = 35900 # GL/glext.h:3592
# EXT_texture_array (GL/glext.h:3595)
GL_TEXTURE_1D_ARRAY_EXT = 35864 # GL/glext.h:3596
GL_PROXY_TEXTURE_1D_ARRAY_EXT = 35865 # GL/glext.h:3597
GL_TEXTURE_2D_ARRAY_EXT = 35866 # GL/glext.h:3598
GL_PROXY_TEXTURE_2D_ARRAY_EXT = 35867 # GL/glext.h:3599
GL_TEXTURE_BINDING_1D_ARRAY_EXT = 35868 # GL/glext.h:3600
GL_TEXTURE_BINDING_2D_ARRAY_EXT = 35869 # GL/glext.h:3601
GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 35071 # GL/glext.h:3602
GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 34894 # GL/glext.h:3603
# EXT_texture_integer (GL/glext.h:3607)
GL_RGBA32UI_EXT = 36208 # GL/glext.h:3608
GL_RGB32UI_EXT = 36209 # GL/glext.h:3609
GL_ALPHA32UI_EXT = 36210 # GL/glext.h:3610
GL_INTENSITY32UI_EXT = 36211 # GL/glext.h:3611
GL_LUMINANCE32UI_EXT = 36212 # GL/glext.h:3612
GL_LUMINANCE_ALPHA32UI_EXT = 36213 # GL/glext.h:3613
GL_RGBA16UI_EXT = 36214 # GL/glext.h:3614
GL_RGB16UI_EXT = 36215 # GL/glext.h:3615
GL_ALPHA16UI_EXT = 36216 # GL/glext.h:3616
GL_INTENSITY16UI_EXT = 36217 # GL/glext.h:3617
GL_LUMINANCE16UI_EXT = 36218 # GL/glext.h:3618
GL_LUMINANCE_ALPHA16UI_EXT = 36219 # GL/glext.h:3619
GL_RGBA8UI_EXT = 36220 # GL/glext.h:3620
GL_RGB8UI_EXT = 36221 # GL/glext.h:3621
GL_ALPHA8UI_EXT = 36222 # GL/glext.h:3622
GL_INTENSITY8UI_EXT = 36223 # GL/glext.h:3623
GL_LUMINANCE8UI_EXT = 36224 # GL/glext.h:3624
GL_LUMINANCE_ALPHA8UI_EXT = 36225 # GL/glext.h:3625
GL_RGBA32I_EXT = 36226 # GL/glext.h:3626
GL_RGB32I_EXT = 36227 # GL/glext.h:3627
GL_ALPHA32I_EXT = 36228 # GL/glext.h:3628
GL_INTENSITY32I_EXT = 36229 # GL/glext.h:3629
GL_LUMINANCE32I_EXT = 36230 # GL/glext.h:3630
GL_LUMINANCE_ALPHA32I_EXT = 36231 # GL/glext.h:3631
GL_RGBA16I_EXT = 36232 # GL/glext.h:3632
GL_RGB16I_EXT = 36233 # GL/glext.h:3633
GL_ALPHA16I_EXT = 36234 # GL/glext.h:3634
GL_INTENSITY16I_EXT = 36235 # GL/glext.h:3635
GL_LUMINANCE16I_EXT = 36236 # GL/glext.h:3636
GL_LUMINANCE_ALPHA16I_EXT = 36237 # GL/glext.h:3637
GL_RGBA8I_EXT = 36238 # GL/glext.h:3638
GL_RGB8I_EXT = 36239 # GL/glext.h:3639
GL_ALPHA8I_EXT = 36240 # GL/glext.h:3640
GL_INTENSITY8I_EXT = 36241 # GL/glext.h:3641
GL_LUMINANCE8I_EXT = 36242 # GL/glext.h:3642
GL_LUMINANCE_ALPHA8I_EXT = 36243 # GL/glext.h:3643
GL_RED_INTEGER_EXT = 36244 # GL/glext.h:3644
GL_GREEN_INTEGER_EXT = 36245 # GL/glext.h:3645
GL_BLUE_INTEGER_EXT = 36246 # GL/glext.h:3646
GL_ALPHA_INTEGER_EXT = 36247 # GL/glext.h:3647
GL_RGB_INTEGER_EXT = 36248 # GL/glext.h:3648
GL_RGBA_INTEGER_EXT = 36249 # GL/glext.h:3649
GL_BGR_INTEGER_EXT = 36250 # GL/glext.h:3650
GL_BGRA_INTEGER_EXT = 36251 # GL/glext.h:3651
GL_LUMINANCE_INTEGER_EXT = 36252 # GL/glext.h:3652
GL_LUMINANCE_ALPHA_INTEGER_EXT = 36253 # GL/glext.h:3653
GL_RGBA_INTEGER_MODE_EXT = 36254 # GL/glext.h:3654
# NV_depth_buffer_float (GL/glext.h:3657)
GL_DEPTH_COMPONENT32F_NV = 36267 # GL/glext.h:3658
GL_DEPTH32F_STENCIL8_NV = 36268 # GL/glext.h:3659
GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 36269 # GL/glext.h:3660
GL_DEPTH_BUFFER_FLOAT_MODE_NV = 36271 # GL/glext.h:3661
# EXT_texture_compression_latc (GL/glext.h:3664)
GL_COMPRESSED_LUMINANCE_LATC1_EXT = 35952 # GL/glext.h:3665
GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 35953 # GL/glext.h:3666
GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 35954 # GL/glext.h:3667
GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 35955 # GL/glext.h:3668
# NV_transform_feedback (GL/glext.h:3671)
GL_BACK_PRIMARY_COLOR_NV = 35959 # GL/glext.h:3672
GL_BACK_SECONDARY_COLOR_NV = 35960 # GL/glext.h:3673
GL_TEXTURE_COORD_NV = 35961 # GL/glext.h:3674
GL_CLIP_DISTANCE_NV = 35962 # GL/glext.h:3675
GL_VERTEX_ID_NV = 35963 # GL/glext.h:3676
GL_PRIMITIVE_ID_NV = 35964 # GL/glext.h:3677
GL_GENERIC_ATTRIB_NV = 35965 # GL/glext.h:3678
GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 35966 # GL/glext.h:3679
GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 35967 # GL/glext.h:3680
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 35968 # GL/glext.h:3681
GL_ACTIVE_VARYINGS_NV = 35969 # GL/glext.h:3682
GL_ACTIVE_VARYING_MAX_LENGTH_NV = 35970 # GL/glext.h:3683
GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 35971 # GL/glext.h:3684
GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 35972 # GL/glext.h:3685
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 35973 # GL/glext.h:3686
GL_TRANSFORM_FEEDBACK_RECORD_NV = 35974 # GL/glext.h:3687
GL_PRIMITIVES_GENERATED_NV = 35975 # GL/glext.h:3688
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 35976 # GL/glext.h:3689
GL_RASTERIZER_DISCARD_NV = 35977 # GL/glext.h:3690
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 35978 # GL/glext.h:3691
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 35979 # GL/glext.h:3692
GL_INTERLEAVED_ATTRIBS_NV = 35980 # GL/glext.h:3693
GL_SEPARATE_ATTRIBS_NV = 35981 # GL/glext.h:3694
GL_TRANSFORM_FEEDBACK_BUFFER_NV = 35982 # GL/glext.h:3695
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 35983 # GL/glext.h:3696
# NV_geometry_program4 (GL/glext.h:3699)
GL_GEOMETRY_PROGRAM_NV = 35878 # GL/glext.h:3700
GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 35879 # GL/glext.h:3701
GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 35880 # GL/glext.h:3702
# NV_gpu_program4 (GL/glext.h:3705)
GL_MIN_PROGRAM_TEXEL_OFFSET_NV = 35076 # GL/glext.h:3706
GL_MAX_PROGRAM_TEXEL_OFFSET_NV = 35077 # GL/glext.h:3707
GL_PROGRAM_ATTRIB_COMPONENTS_NV = 35078 # GL/glext.h:3708
GL_PROGRAM_RESULT_COMPONENTS_NV = 35079 # GL/glext.h:3709
GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 35080 # GL/glext.h:3710
GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 35081 # GL/glext.h:3711
GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 36261 # GL/glext.h:3712
GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 36262 # GL/glext.h:3713
GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 36256 # GL/glext.h:3717
GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 36257 # GL/glext.h:3718
GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 36258 # GL/glext.h:3719
GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 36259 # GL/glext.h:3720
GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 36260 # GL/glext.h:3721
# NV_framebuffer_multisample_coverage (GL/glext.h:3724)
GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 36011 # GL/glext.h:3725
GL_RENDERBUFFER_COLOR_SAMPLES_NV = 36368 # GL/glext.h:3726
GL_MAX_RENDERBUFFER_COVERAGE_SAMPLES_NV = 36183 # GL/glext.h:3727
GL_MAX_RENDERBUFFER_COLOR_SAMPLES_NV = 36369 # GL/glext.h:3728
GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 36370 # GL/glext.h:3729
GL_MULTISAMPLE_COVERAGE_MODES_NV = 36371 # GL/glext.h:3730
# EXT_framebuffer_multisample (GL/glext.h:3733)
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 36182 # GL/glext.h:3734
GL_MAX_SAMPLES_EXT = 36183 # GL/glext.h:3735
GL_RENDERBUFFER_SAMPLES_EXT = 36011 # GL/glext.h:3736
# EXT_framebuffer_blit (GL/glext.h:3739)
GL_READ_FRAMEBUFFER_EXT = 36008 # GL/glext.h:3740
GL_DRAW_FRAMEBUFFER_EXT = 36009 # GL/glext.h:3741
GL_DRAW_FRAMEBUFFER_BINDING_EXT = 36006 # GL/glext.h:3742
GL_READ_FRAMEBUFFER_BINDING_EXT = 36010 # GL/glext.h:3743
# EXT_texture_compression_rgtc (GL/glext.h:3746)
GL_COMPRESSED_RED_RGTC1_EXT = 36283 # GL/glext.h:3747
GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 36284 # GL/glext.h:3748
GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 36285 # GL/glext.h:3749
GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 36286 # GL/glext.h:3750
# NV_present_video (GL/glext.h:3753)
GL_FRAME_NV = 36390 # GL/glext.h:3754
GL_FIELDS_NV = 36391 # GL/glext.h:3755
GL_CURRENT_TIME_NV = 36392 # GL/glext.h:3756
GL_NUM_FILL_STREAMS_NV = 36393 # GL/glext.h:3757
GL_PRESENT_TIME_NV = 36394 # GL/glext.h:3758
GL_PRESENT_DURATION_NV = 36395 # GL/glext.h:3759
# NV_conditional_render (GL/glext.h:3762)
GL_QUERY_WAIT_NV = 36371 # GL/glext.h:3763
GL_QUERY_NO_WAIT_NV = 36372 # GL/glext.h:3764
GL_QUERY_BY_REGION_WAIT_NV = 36373 # GL/glext.h:3765
GL_QUERY_BY_REGION_NO_WAIT_NV = 36374 # GL/glext.h:3766
# EXT_transform_feedback (GL/glext.h:3769)
GL_TRANSFORM_FEEDBACK_BUFFER_EXT = 35982 # GL/glext.h:3770
GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 35972 # GL/glext.h:3771
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 35973 # GL/glext.h:3772
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 35983 # GL/glext.h:3773
GL_INTERLEAVED_ATTRIBS_EXT = 35980 # GL/glext.h:3774
GL_SEPARATE_ATTRIBS_EXT = 35981 # GL/glext.h:3775
GL_PRIMITIVES_GENERATED_EXT = 35975 # GL/glext.h:3776
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 35976 # GL/glext.h:3777
GL_RASTERIZER_DISCARD_EXT = 35977 # GL/glext.h:3778
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 35978 # GL/glext.h:3779
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 35979 # GL/glext.h:3780
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 35968 # GL/glext.h:3781
GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 35971 # GL/glext.h:3782
GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 35967 # GL/glext.h:3783
GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 35958 # GL/glext.h:3784
# EXT_direct_state_access (GL/glext.h:3787)
GL_PROGRAM_MATRIX_EXT = 36397 # GL/glext.h:3788
GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 36398 # GL/glext.h:3789
GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 36399 # GL/glext.h:3790
# EXT_vertex_array_bgra (GL/glext.h:3793)
# EXT_texture_swizzle (GL/glext.h:3797)
GL_TEXTURE_SWIZZLE_R_EXT = 36418 # GL/glext.h:3798
GL_TEXTURE_SWIZZLE_G_EXT = 36419 # GL/glext.h:3799
GL_TEXTURE_SWIZZLE_B_EXT = 36420 # GL/glext.h:3800
GL_TEXTURE_SWIZZLE_A_EXT = 36421 # GL/glext.h:3801
GL_TEXTURE_SWIZZLE_RGBA_EXT = 36422 # GL/glext.h:3802
# NV_explicit_multisample (GL/glext.h:3805)
GL_SAMPLE_POSITION_NV = 36432 # GL/glext.h:3806
GL_SAMPLE_MASK_NV = 36433 # GL/glext.h:3807
GL_SAMPLE_MASK_VALUE_NV = 36434 # GL/glext.h:3808
GL_TEXTURE_BINDING_RENDERBUFFER_NV = 36435 # GL/glext.h:3809
GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 36436 # GL/glext.h:3810
GL_MAX_SAMPLE_MASK_WORDS_NV = 36441 # GL/glext.h:3811
GL_TEXTURE_RENDERBUFFER_NV = 36437 # GL/glext.h:3812
GL_SAMPLER_RENDERBUFFER_NV = 36438 # GL/glext.h:3813
GL_INT_SAMPLER_RENDERBUFFER_NV = 36439 # GL/glext.h:3814
GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 36440 # GL/glext.h:3815
# NV_transform_feedback2 (GL/glext.h:3818)
GL_TRANSFORM_FEEDBACK_NV = 36386 # GL/glext.h:3819
GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 36387 # GL/glext.h:3820
GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 36388 # GL/glext.h:3821
GL_TRANSFORM_FEEDBACK_BINDING_NV = 36389 # GL/glext.h:3822
# NV_vertex_buffer_unified_memory (GL/glext.h:3825)
GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 36638 # GL/glext.h:3826
GL_ELEMENT_ARRAY_UNIFIED_NV = 36639 # GL/glext.h:3827
GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 36640 # GL/glext.h:3828
GL_VERTEX_ARRAY_ADDRESS_NV = 36641 # GL/glext.h:3829
GL_NORMAL_ARRAY_ADDRESS_NV = 36642 # GL/glext.h:3830
GL_COLOR_ARRAY_ADDRESS_NV = 36643 # GL/glext.h:3831
GL_INDEX_ARRAY_ADDRESS_NV = 36644 # GL/glext.h:3832
GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 36645 # GL/glext.h:3833
GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 36646 # GL/glext.h:3834
GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 36647 # GL/glext.h:3835
GL_FOG_COORD_ARRAY_ADDRESS_NV = 36648 # GL/glext.h:3836
GL_ELEMENT_ARRAY_ADDRESS_NV = 36649 # GL/glext.h:3837
GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 36650 # GL/glext.h:3838
GL_VERTEX_ARRAY_LENGTH_NV = 36651 # GL/glext.h:3839
GL_NORMAL_ARRAY_LENGTH_NV = 36652 # GL/glext.h:3840
GL_COLOR_ARRAY_LENGTH_NV = 36653 # GL/glext.h:3841
GL_INDEX_ARRAY_LENGTH_NV = 36654 # GL/glext.h:3842
GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 36655 # GL/glext.h:3843
GL_EDGE_FLAG_ARRAY_LENGTH_NV = 36656 # GL/glext.h:3844
GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 36657 # GL/glext.h:3845
GL_FOG_COORD_ARRAY_LENGTH_NV = 36658 # GL/glext.h:3846
GL_ELEMENT_ARRAY_LENGTH_NV = 36659 # GL/glext.h:3847
# NV_shader_buffer_load (GL/glext.h:3850)
GL_BUFFER_GPU_ADDRESS_NV = 36637 # GL/glext.h:3851
GL_GPU_ADDRESS_NV = 36660 # GL/glext.h:3852
GL_MAX_SHADER_BUFFER_ADDRESS_NV = 36661 # GL/glext.h:3853
# VERSION_2_0 (GL/glext.h:3859)
GLchar = c_char # GL/glext.h:3861
# VERSION_1_5 (GL/glext.h:3864)
GLintptr = c_ptrdiff_t # GL/glext.h:3866
GLsizeiptr = c_ptrdiff_t # GL/glext.h:3867
# ARB_vertex_buffer_object (GL/glext.h:3870)
GLintptrARB = c_ptrdiff_t # GL/glext.h:3872
GLsizeiptrARB = c_ptrdiff_t # GL/glext.h:3873
# ARB_shader_objects (GL/glext.h:3876)
GLcharARB = c_char # GL/glext.h:3878
GLhandleARB = c_uint # GL/glext.h:3879
# ARB_half_float_pixel (GL/glext.h:3883)
GLhalfARB = c_ushort # GL/glext.h:3884
# NV_half_float (GL/glext.h:3887)
GLhalfNV = c_ushort # GL/glext.h:3888
# EXT_timer_query (GL/glext.h:3891)
GLint64EXT = c_longlong # GL/glext.h:3892
GLuint64EXT = c_ulonglong # GL/glext.h:3893
# VERSION_1_2 (GL/glext.h:3896)
# VERSION_1_3 (GL/glext.h:3978)
# VERSION_1_4 (GL/glext.h:4076)
GL_VERSION_1_4 = 1 # GL/glext.h:4077
GLenum = c_uint # /usr/include/GL/gl.h:149
# GL/glext.h:4079
glBlendFuncSeparate = _link_function('glBlendFuncSeparate', None, [GLenum, GLenum, GLenum, GLenum], 'VERSION_1_4')
GLfloat = c_float # /usr/include/GL/gl.h:160
# GL/glext.h:4080
glFogCoordf = _link_function('glFogCoordf', None, [GLfloat], 'VERSION_1_4')
# GL/glext.h:4081
glFogCoordfv = _link_function('glFogCoordfv', None, [POINTER(GLfloat)], 'VERSION_1_4')
GLdouble = c_double # /usr/include/GL/gl.h:162
# GL/glext.h:4082
glFogCoordd = _link_function('glFogCoordd', None, [GLdouble], 'VERSION_1_4')
# GL/glext.h:4083
glFogCoorddv = _link_function('glFogCoorddv', None, [POINTER(GLdouble)], 'VERSION_1_4')
GLsizei = c_int # /usr/include/GL/gl.h:159
GLvoid = None # /usr/include/GL/gl.h:152
# GL/glext.h:4084
glFogCoordPointer = _link_function('glFogCoordPointer', None, [GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_1_4')
GLint = c_int # /usr/include/GL/gl.h:155
# GL/glext.h:4085
glMultiDrawArrays = _link_function('glMultiDrawArrays', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'VERSION_1_4')
# GL/glext.h:4086
glMultiDrawElements = _link_function('glMultiDrawElements', None, [GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei], 'VERSION_1_4')
# GL/glext.h:4087
glPointParameterf = _link_function('glPointParameterf', None, [GLenum, GLfloat], 'VERSION_1_4')
# GL/glext.h:4088
glPointParameterfv = _link_function('glPointParameterfv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_4')
# GL/glext.h:4089
glPointParameteri = _link_function('glPointParameteri', None, [GLenum, GLint], 'VERSION_1_4')
# GL/glext.h:4090
glPointParameteriv = _link_function('glPointParameteriv', None, [GLenum, POINTER(GLint)], 'VERSION_1_4')
GLbyte = c_char # /usr/include/GL/gl.h:153
# GL/glext.h:4091
glSecondaryColor3b = _link_function('glSecondaryColor3b', None, [GLbyte, GLbyte, GLbyte], 'VERSION_1_4')
# GL/glext.h:4092
glSecondaryColor3bv = _link_function('glSecondaryColor3bv', None, [POINTER(GLbyte)], 'VERSION_1_4')
# GL/glext.h:4093
glSecondaryColor3d = _link_function('glSecondaryColor3d', None, [GLdouble, GLdouble, GLdouble], 'VERSION_1_4')
# GL/glext.h:4094
glSecondaryColor3dv = _link_function('glSecondaryColor3dv', None, [POINTER(GLdouble)], 'VERSION_1_4')
# GL/glext.h:4095
glSecondaryColor3f = _link_function('glSecondaryColor3f', None, [GLfloat, GLfloat, GLfloat], 'VERSION_1_4')
# GL/glext.h:4096
glSecondaryColor3fv = _link_function('glSecondaryColor3fv', None, [POINTER(GLfloat)], 'VERSION_1_4')
# GL/glext.h:4097
glSecondaryColor3i = _link_function('glSecondaryColor3i', None, [GLint, GLint, GLint], 'VERSION_1_4')
# GL/glext.h:4098
glSecondaryColor3iv = _link_function('glSecondaryColor3iv', None, [POINTER(GLint)], 'VERSION_1_4')
GLshort = c_short # /usr/include/GL/gl.h:154
# GL/glext.h:4099
glSecondaryColor3s = _link_function('glSecondaryColor3s', None, [GLshort, GLshort, GLshort], 'VERSION_1_4')
# GL/glext.h:4100
glSecondaryColor3sv = _link_function('glSecondaryColor3sv', None, [POINTER(GLshort)], 'VERSION_1_4')
GLubyte = c_ubyte # /usr/include/GL/gl.h:156
# GL/glext.h:4101
glSecondaryColor3ub = _link_function('glSecondaryColor3ub', None, [GLubyte, GLubyte, GLubyte], 'VERSION_1_4')
# GL/glext.h:4102
glSecondaryColor3ubv = _link_function('glSecondaryColor3ubv', None, [POINTER(GLubyte)], 'VERSION_1_4')
GLuint = c_uint # /usr/include/GL/gl.h:158
# GL/glext.h:4103
glSecondaryColor3ui = _link_function('glSecondaryColor3ui', None, [GLuint, GLuint, GLuint], 'VERSION_1_4')
# GL/glext.h:4104
glSecondaryColor3uiv = _link_function('glSecondaryColor3uiv', None, [POINTER(GLuint)], 'VERSION_1_4')
GLushort = c_ushort # /usr/include/GL/gl.h:157
# GL/glext.h:4105
glSecondaryColor3us = _link_function('glSecondaryColor3us', None, [GLushort, GLushort, GLushort], 'VERSION_1_4')
# GL/glext.h:4106
glSecondaryColor3usv = _link_function('glSecondaryColor3usv', None, [POINTER(GLushort)], 'VERSION_1_4')
# GL/glext.h:4107
glSecondaryColorPointer = _link_function('glSecondaryColorPointer', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_1_4')
# GL/glext.h:4108
glWindowPos2d = _link_function('glWindowPos2d', None, [GLdouble, GLdouble], 'VERSION_1_4')
# GL/glext.h:4109
glWindowPos2dv = _link_function('glWindowPos2dv', None, [POINTER(GLdouble)], 'VERSION_1_4')
# GL/glext.h:4110
glWindowPos2f = _link_function('glWindowPos2f', None, [GLfloat, GLfloat], 'VERSION_1_4')
# GL/glext.h:4111
glWindowPos2fv = _link_function('glWindowPos2fv', None, [POINTER(GLfloat)], 'VERSION_1_4')
# GL/glext.h:4112
glWindowPos2i = _link_function('glWindowPos2i', None, [GLint, GLint], 'VERSION_1_4')
# GL/glext.h:4113
glWindowPos2iv = _link_function('glWindowPos2iv', None, [POINTER(GLint)], 'VERSION_1_4')
# GL/glext.h:4114
glWindowPos2s = _link_function('glWindowPos2s', None, [GLshort, GLshort], 'VERSION_1_4')
# GL/glext.h:4115
glWindowPos2sv = _link_function('glWindowPos2sv', None, [POINTER(GLshort)], 'VERSION_1_4')
# GL/glext.h:4116
glWindowPos3d = _link_function('glWindowPos3d', None, [GLdouble, GLdouble, GLdouble], 'VERSION_1_4')
# GL/glext.h:4117
glWindowPos3dv = _link_function('glWindowPos3dv', None, [POINTER(GLdouble)], 'VERSION_1_4')
# GL/glext.h:4118
glWindowPos3f = _link_function('glWindowPos3f', None, [GLfloat, GLfloat, GLfloat], 'VERSION_1_4')
# GL/glext.h:4119
glWindowPos3fv = _link_function('glWindowPos3fv', None, [POINTER(GLfloat)], 'VERSION_1_4')
# GL/glext.h:4120
glWindowPos3i = _link_function('glWindowPos3i', None, [GLint, GLint, GLint], 'VERSION_1_4')
# GL/glext.h:4121
glWindowPos3iv = _link_function('glWindowPos3iv', None, [POINTER(GLint)], 'VERSION_1_4')
# GL/glext.h:4122
glWindowPos3s = _link_function('glWindowPos3s', None, [GLshort, GLshort, GLshort], 'VERSION_1_4')
# GL/glext.h:4123
glWindowPos3sv = _link_function('glWindowPos3sv', None, [POINTER(GLshort)], 'VERSION_1_4')
PFNGLBLENDFUNCSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:4125
PFNGLFOGCOORDFPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:4126
PFNGLFOGCOORDFVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4127
PFNGLFOGCOORDDPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:4128
PFNGLFOGCOORDDVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4129
PFNGLFOGCOORDPOINTERPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4130
PFNGLMULTIDRAWARRAYSPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:4131
PFNGLMULTIDRAWELEMENTSPROC = CFUNCTYPE(None, GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei) # GL/glext.h:4132
PFNGLPOINTPARAMETERFPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:4133
PFNGLPOINTPARAMETERFVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:4134
PFNGLPOINTPARAMETERIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:4135
PFNGLPOINTPARAMETERIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:4136
PFNGLSECONDARYCOLOR3BPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:4137
PFNGLSECONDARYCOLOR3BVPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:4138
PFNGLSECONDARYCOLOR3DPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:4139
PFNGLSECONDARYCOLOR3DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4140
PFNGLSECONDARYCOLOR3FPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:4141
PFNGLSECONDARYCOLOR3FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4142
PFNGLSECONDARYCOLOR3IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:4143
PFNGLSECONDARYCOLOR3IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:4144
PFNGLSECONDARYCOLOR3SPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:4145
PFNGLSECONDARYCOLOR3SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:4146
PFNGLSECONDARYCOLOR3UBPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte) # GL/glext.h:4147
PFNGLSECONDARYCOLOR3UBVPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:4148
PFNGLSECONDARYCOLOR3UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:4149
PFNGLSECONDARYCOLOR3UIVPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:4150
PFNGLSECONDARYCOLOR3USPROC = CFUNCTYPE(None, GLushort, GLushort, GLushort) # GL/glext.h:4151
PFNGLSECONDARYCOLOR3USVPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:4152
PFNGLSECONDARYCOLORPOINTERPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4153
PFNGLWINDOWPOS2DPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:4154
PFNGLWINDOWPOS2DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4155
PFNGLWINDOWPOS2FPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:4156
PFNGLWINDOWPOS2FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4157
PFNGLWINDOWPOS2IPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:4158
PFNGLWINDOWPOS2IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:4159
PFNGLWINDOWPOS2SPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:4160
PFNGLWINDOWPOS2SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:4161
PFNGLWINDOWPOS3DPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:4162
PFNGLWINDOWPOS3DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4163
PFNGLWINDOWPOS3FPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:4164
PFNGLWINDOWPOS3FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4165
PFNGLWINDOWPOS3IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:4166
PFNGLWINDOWPOS3IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:4167
PFNGLWINDOWPOS3SPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:4168
PFNGLWINDOWPOS3SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:4169
# VERSION_1_5 (GL/glext.h:4172)
GL_VERSION_1_5 = 1 # GL/glext.h:4173
# GL/glext.h:4175
glGenQueries = _link_function('glGenQueries', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:4176
glDeleteQueries = _link_function('glDeleteQueries', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
GLboolean = c_ubyte # /usr/include/GL/gl.h:150
# GL/glext.h:4177
glIsQuery = _link_function('glIsQuery', GLboolean, [GLuint], 'VERSION_1_5')
# GL/glext.h:4178
glBeginQuery = _link_function('glBeginQuery', None, [GLenum, GLuint], 'VERSION_1_5')
# GL/glext.h:4179
glEndQuery = _link_function('glEndQuery', None, [GLenum], 'VERSION_1_5')
# GL/glext.h:4180
glGetQueryiv = _link_function('glGetQueryiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:4181
glGetQueryObjectiv = _link_function('glGetQueryObjectiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:4182
glGetQueryObjectuiv = _link_function('glGetQueryObjectuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:4183
glBindBuffer = _link_function('glBindBuffer', None, [GLenum, GLuint], 'VERSION_1_5')
# GL/glext.h:4184
glDeleteBuffers = _link_function('glDeleteBuffers', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:4185
glGenBuffers = _link_function('glGenBuffers', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:4186
glIsBuffer = _link_function('glIsBuffer', GLboolean, [GLuint], 'VERSION_1_5')
# GL/glext.h:4187
glBufferData = _link_function('glBufferData', None, [GLenum, GLsizeiptr, POINTER(GLvoid), GLenum], 'VERSION_1_5')
# GL/glext.h:4188
glBufferSubData = _link_function('glBufferSubData', None, [GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'VERSION_1_5')
# GL/glext.h:4189
glGetBufferSubData = _link_function('glGetBufferSubData', None, [GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'VERSION_1_5')
# GL/glext.h:4190
glMapBuffer = _link_function('glMapBuffer', POINTER(GLvoid), [GLenum, GLenum], 'VERSION_1_5')
# GL/glext.h:4191
glUnmapBuffer = _link_function('glUnmapBuffer', GLboolean, [GLenum], 'VERSION_1_5')
# GL/glext.h:4192
glGetBufferParameteriv = _link_function('glGetBufferParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:4193
glGetBufferPointerv = _link_function('glGetBufferPointerv', None, [GLenum, GLenum, POINTER(POINTER(GLvoid))], 'VERSION_1_5')
PFNGLGENQUERIESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4195
PFNGLDELETEQUERIESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4196
PFNGLISQUERYPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4197
PFNGLBEGINQUERYPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4198
PFNGLENDQUERYPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:4199
PFNGLGETQUERYIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4200
PFNGLGETQUERYOBJECTIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4201
PFNGLGETQUERYOBJECTUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:4202
PFNGLBINDBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4203
PFNGLDELETEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4204
PFNGLGENBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4205
PFNGLISBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4206
PFNGLBUFFERDATAPROC = CFUNCTYPE(None, GLenum, GLsizeiptr, POINTER(GLvoid), GLenum) # GL/glext.h:4207
PFNGLBUFFERSUBDATAPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:4208
PFNGLGETBUFFERSUBDATAPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:4209
PFNGLMAPBUFFERPROC = CFUNCTYPE(POINTER(GLvoid), GLenum, GLenum) # GL/glext.h:4210
PFNGLUNMAPBUFFERPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:4211
PFNGLGETBUFFERPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4212
PFNGLGETBUFFERPOINTERVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:4213
# VERSION_2_0 (GL/glext.h:4216)
GL_VERSION_2_0 = 1 # GL/glext.h:4217
# GL/glext.h:4219
glBlendEquationSeparate = _link_function('glBlendEquationSeparate', None, [GLenum, GLenum], 'VERSION_2_0')
# GL/glext.h:4220
glDrawBuffers = _link_function('glDrawBuffers', None, [GLsizei, POINTER(GLenum)], 'VERSION_2_0')
# GL/glext.h:4221
glStencilOpSeparate = _link_function('glStencilOpSeparate', None, [GLenum, GLenum, GLenum, GLenum], 'VERSION_2_0')
# GL/glext.h:4222
glStencilFuncSeparate = _link_function('glStencilFuncSeparate', None, [GLenum, GLenum, GLint, GLuint], 'VERSION_2_0')
# GL/glext.h:4223
glStencilMaskSeparate = _link_function('glStencilMaskSeparate', None, [GLenum, GLuint], 'VERSION_2_0')
# GL/glext.h:4224
glAttachShader = _link_function('glAttachShader', None, [GLuint, GLuint], 'VERSION_2_0')
# GL/glext.h:4225
glBindAttribLocation = _link_function('glBindAttribLocation', None, [GLuint, GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4226
glCompileShader = _link_function('glCompileShader', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4227
glCreateProgram = _link_function('glCreateProgram', GLuint, [], 'VERSION_2_0')
# GL/glext.h:4228
glCreateShader = _link_function('glCreateShader', GLuint, [GLenum], 'VERSION_2_0')
# GL/glext.h:4229
glDeleteProgram = _link_function('glDeleteProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4230
glDeleteShader = _link_function('glDeleteShader', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4231
glDetachShader = _link_function('glDetachShader', None, [GLuint, GLuint], 'VERSION_2_0')
# GL/glext.h:4232
glDisableVertexAttribArray = _link_function('glDisableVertexAttribArray', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4233
glEnableVertexAttribArray = _link_function('glEnableVertexAttribArray', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4234
glGetActiveAttrib = _link_function('glGetActiveAttrib', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4235
glGetActiveUniform = _link_function('glGetActiveUniform', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4236
glGetAttachedShaders = _link_function('glGetAttachedShaders', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:4237
glGetAttribLocation = _link_function('glGetAttribLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4238
glGetProgramiv = _link_function('glGetProgramiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4239
glGetProgramInfoLog = _link_function('glGetProgramInfoLog', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4240
glGetShaderiv = _link_function('glGetShaderiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4241
glGetShaderInfoLog = _link_function('glGetShaderInfoLog', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4242
glGetShaderSource = _link_function('glGetShaderSource', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4243
glGetUniformLocation = _link_function('glGetUniformLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:4244
glGetUniformfv = _link_function('glGetUniformfv', None, [GLuint, GLint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4245
glGetUniformiv = _link_function('glGetUniformiv', None, [GLuint, GLint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4246
glGetVertexAttribdv = _link_function('glGetVertexAttribdv', None, [GLuint, GLenum, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:4247
glGetVertexAttribfv = _link_function('glGetVertexAttribfv', None, [GLuint, GLenum, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4248
glGetVertexAttribiv = _link_function('glGetVertexAttribiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4249
glGetVertexAttribPointerv = _link_function('glGetVertexAttribPointerv', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'VERSION_2_0')
# GL/glext.h:4250
glIsProgram = _link_function('glIsProgram', GLboolean, [GLuint], 'VERSION_2_0')
# GL/glext.h:4251
glIsShader = _link_function('glIsShader', GLboolean, [GLuint], 'VERSION_2_0')
# GL/glext.h:4252
glLinkProgram = _link_function('glLinkProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4253
glShaderSource = _link_function('glShaderSource', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4254
glUseProgram = _link_function('glUseProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4255
glUniform1f = _link_function('glUniform1f', None, [GLint, GLfloat], 'VERSION_2_0')
# GL/glext.h:4256
glUniform2f = _link_function('glUniform2f', None, [GLint, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4257
glUniform3f = _link_function('glUniform3f', None, [GLint, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4258
glUniform4f = _link_function('glUniform4f', None, [GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4259
glUniform1i = _link_function('glUniform1i', None, [GLint, GLint], 'VERSION_2_0')
# GL/glext.h:4260
glUniform2i = _link_function('glUniform2i', None, [GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:4261
glUniform3i = _link_function('glUniform3i', None, [GLint, GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:4262
glUniform4i = _link_function('glUniform4i', None, [GLint, GLint, GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:4263
glUniform1fv = _link_function('glUniform1fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4264
glUniform2fv = _link_function('glUniform2fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4265
glUniform3fv = _link_function('glUniform3fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4266
glUniform4fv = _link_function('glUniform4fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4267
glUniform1iv = _link_function('glUniform1iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4268
glUniform2iv = _link_function('glUniform2iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4269
glUniform3iv = _link_function('glUniform3iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4270
glUniform4iv = _link_function('glUniform4iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4271
glUniformMatrix2fv = _link_function('glUniformMatrix2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4272
glUniformMatrix3fv = _link_function('glUniformMatrix3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4273
glUniformMatrix4fv = _link_function('glUniformMatrix4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4274
glValidateProgram = _link_function('glValidateProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:4275
glVertexAttrib1d = _link_function('glVertexAttrib1d', None, [GLuint, GLdouble], 'VERSION_2_0')
# GL/glext.h:4276
glVertexAttrib1dv = _link_function('glVertexAttrib1dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:4277
glVertexAttrib1f = _link_function('glVertexAttrib1f', None, [GLuint, GLfloat], 'VERSION_2_0')
# GL/glext.h:4278
glVertexAttrib1fv = _link_function('glVertexAttrib1fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4279
glVertexAttrib1s = _link_function('glVertexAttrib1s', None, [GLuint, GLshort], 'VERSION_2_0')
# GL/glext.h:4280
glVertexAttrib1sv = _link_function('glVertexAttrib1sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:4281
glVertexAttrib2d = _link_function('glVertexAttrib2d', None, [GLuint, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:4282
glVertexAttrib2dv = _link_function('glVertexAttrib2dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:4283
glVertexAttrib2f = _link_function('glVertexAttrib2f', None, [GLuint, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4284
glVertexAttrib2fv = _link_function('glVertexAttrib2fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4285
glVertexAttrib2s = _link_function('glVertexAttrib2s', None, [GLuint, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:4286
glVertexAttrib2sv = _link_function('glVertexAttrib2sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:4287
glVertexAttrib3d = _link_function('glVertexAttrib3d', None, [GLuint, GLdouble, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:4288
glVertexAttrib3dv = _link_function('glVertexAttrib3dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:4289
glVertexAttrib3f = _link_function('glVertexAttrib3f', None, [GLuint, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4290
glVertexAttrib3fv = _link_function('glVertexAttrib3fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4291
glVertexAttrib3s = _link_function('glVertexAttrib3s', None, [GLuint, GLshort, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:4292
glVertexAttrib3sv = _link_function('glVertexAttrib3sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:4293
glVertexAttrib4Nbv = _link_function('glVertexAttrib4Nbv', None, [GLuint, POINTER(GLbyte)], 'VERSION_2_0')
# GL/glext.h:4294
glVertexAttrib4Niv = _link_function('glVertexAttrib4Niv', None, [GLuint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4295
glVertexAttrib4Nsv = _link_function('glVertexAttrib4Nsv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:4296
glVertexAttrib4Nub = _link_function('glVertexAttrib4Nub', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'VERSION_2_0')
# GL/glext.h:4297
glVertexAttrib4Nubv = _link_function('glVertexAttrib4Nubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_2_0')
# GL/glext.h:4298
glVertexAttrib4Nuiv = _link_function('glVertexAttrib4Nuiv', None, [GLuint, POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:4299
glVertexAttrib4Nusv = _link_function('glVertexAttrib4Nusv', None, [GLuint, POINTER(GLushort)], 'VERSION_2_0')
# GL/glext.h:4300
glVertexAttrib4bv = _link_function('glVertexAttrib4bv', None, [GLuint, POINTER(GLbyte)], 'VERSION_2_0')
# GL/glext.h:4301
glVertexAttrib4d = _link_function('glVertexAttrib4d', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:4302
glVertexAttrib4dv = _link_function('glVertexAttrib4dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:4303
glVertexAttrib4f = _link_function('glVertexAttrib4f', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:4304
glVertexAttrib4fv = _link_function('glVertexAttrib4fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:4305
glVertexAttrib4iv = _link_function('glVertexAttrib4iv', None, [GLuint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:4306
glVertexAttrib4s = _link_function('glVertexAttrib4s', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:4307
glVertexAttrib4sv = _link_function('glVertexAttrib4sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:4308
glVertexAttrib4ubv = _link_function('glVertexAttrib4ubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_2_0')
# GL/glext.h:4309
glVertexAttrib4uiv = _link_function('glVertexAttrib4uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:4310
glVertexAttrib4usv = _link_function('glVertexAttrib4usv', None, [GLuint, POINTER(GLushort)], 'VERSION_2_0')
# GL/glext.h:4311
glVertexAttribPointer = _link_function('glVertexAttribPointer', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)], 'VERSION_2_0')
PFNGLBLENDEQUATIONSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:4313
PFNGLDRAWBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:4314
PFNGLSTENCILOPSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:4315
PFNGLSTENCILFUNCSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLuint) # GL/glext.h:4316
PFNGLSTENCILMASKSEPARATEPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4317
PFNGLATTACHSHADERPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:4318
PFNGLBINDATTRIBLOCATIONPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:4319
PFNGLCOMPILESHADERPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4320
PFNGLCREATEPROGRAMPROC = CFUNCTYPE(GLuint) # GL/glext.h:4321
PFNGLCREATESHADERPROC = CFUNCTYPE(GLuint, GLenum) # GL/glext.h:4322
PFNGLDELETEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4323
PFNGLDELETESHADERPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4324
PFNGLDETACHSHADERPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:4325
PFNGLDISABLEVERTEXATTRIBARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4326
PFNGLENABLEVERTEXATTRIBARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4327
PFNGLGETACTIVEATTRIBPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:4328
PFNGLGETACTIVEUNIFORMPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:4329
PFNGLGETATTACHEDSHADERSPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLuint)) # GL/glext.h:4330
PFNGLGETATTRIBLOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:4331
PFNGLGETPROGRAMIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4332
PFNGLGETPROGRAMINFOLOGPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:4333
PFNGLGETSHADERIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4334
PFNGLGETSHADERINFOLOGPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:4335
PFNGLGETSHADERSOURCEPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:4336
PFNGLGETUNIFORMLOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:4337
PFNGLGETUNIFORMFVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLfloat)) # GL/glext.h:4338
PFNGLGETUNIFORMIVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLint)) # GL/glext.h:4339
PFNGLGETVERTEXATTRIBDVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:4340
PFNGLGETVERTEXATTRIBFVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:4341
PFNGLGETVERTEXATTRIBIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4342
PFNGLGETVERTEXATTRIBPOINTERVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:4343
PFNGLISPROGRAMPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4344
PFNGLISSHADERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4345
PFNGLLINKPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4346
PFNGLSHADERSOURCEPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)) # GL/glext.h:4347
PFNGLUSEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4348
PFNGLUNIFORM1FPROC = CFUNCTYPE(None, GLint, GLfloat) # GL/glext.h:4349
PFNGLUNIFORM2FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat) # GL/glext.h:4350
PFNGLUNIFORM3FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:4351
PFNGLUNIFORM4FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:4352
PFNGLUNIFORM1IPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:4353
PFNGLUNIFORM2IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:4354
PFNGLUNIFORM3IPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:4355
PFNGLUNIFORM4IPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:4356
PFNGLUNIFORM1FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:4357
PFNGLUNIFORM2FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:4358
PFNGLUNIFORM3FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:4359
PFNGLUNIFORM4FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:4360
PFNGLUNIFORM1IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:4361
PFNGLUNIFORM2IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:4362
PFNGLUNIFORM3IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:4363
PFNGLUNIFORM4IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:4364
PFNGLUNIFORMMATRIX2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4365
PFNGLUNIFORMMATRIX3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4366
PFNGLUNIFORMMATRIX4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4367
PFNGLVALIDATEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4368
PFNGLVERTEXATTRIB1DPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:4369
PFNGLVERTEXATTRIB1DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4370
PFNGLVERTEXATTRIB1FPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:4371
PFNGLVERTEXATTRIB1FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4372
PFNGLVERTEXATTRIB1SPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:4373
PFNGLVERTEXATTRIB1SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4374
PFNGLVERTEXATTRIB2DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:4375
PFNGLVERTEXATTRIB2DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4376
PFNGLVERTEXATTRIB2FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:4377
PFNGLVERTEXATTRIB2FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4378
PFNGLVERTEXATTRIB2SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:4379
PFNGLVERTEXATTRIB2SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4380
PFNGLVERTEXATTRIB3DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:4381
PFNGLVERTEXATTRIB3DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4382
PFNGLVERTEXATTRIB3FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:4383
PFNGLVERTEXATTRIB3FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4384
PFNGLVERTEXATTRIB3SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:4385
PFNGLVERTEXATTRIB3SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4386
PFNGLVERTEXATTRIB4NBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:4387
PFNGLVERTEXATTRIB4NIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4388
PFNGLVERTEXATTRIB4NSVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4389
PFNGLVERTEXATTRIB4NUBPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:4390
PFNGLVERTEXATTRIB4NUBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:4391
PFNGLVERTEXATTRIB4NUIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4392
PFNGLVERTEXATTRIB4NUSVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:4393
PFNGLVERTEXATTRIB4BVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:4394
PFNGLVERTEXATTRIB4DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:4395
PFNGLVERTEXATTRIB4DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4396
PFNGLVERTEXATTRIB4FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:4397
PFNGLVERTEXATTRIB4FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4398
PFNGLVERTEXATTRIB4IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4399
PFNGLVERTEXATTRIB4SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:4400
PFNGLVERTEXATTRIB4SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4401
PFNGLVERTEXATTRIB4UBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:4402
PFNGLVERTEXATTRIB4UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4403
PFNGLVERTEXATTRIB4USVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:4404
PFNGLVERTEXATTRIBPOINTERPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)) # GL/glext.h:4405
# VERSION_2_1 (GL/glext.h:4408)
GL_VERSION_2_1 = 1 # GL/glext.h:4409
# GL/glext.h:4411
glUniformMatrix2x3fv = _link_function('glUniformMatrix2x3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:4412
glUniformMatrix3x2fv = _link_function('glUniformMatrix3x2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:4413
glUniformMatrix2x4fv = _link_function('glUniformMatrix2x4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:4414
glUniformMatrix4x2fv = _link_function('glUniformMatrix4x2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:4415
glUniformMatrix3x4fv = _link_function('glUniformMatrix3x4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:4416
glUniformMatrix4x3fv = _link_function('glUniformMatrix4x3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
PFNGLUNIFORMMATRIX2X3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4418
PFNGLUNIFORMMATRIX3X2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4419
PFNGLUNIFORMMATRIX2X4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4420
PFNGLUNIFORMMATRIX4X2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4421
PFNGLUNIFORMMATRIX3X4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4422
PFNGLUNIFORMMATRIX4X3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:4423
# VERSION_3_0 (GL/glext.h:4426)
GL_VERSION_3_0 = 1 # GL/glext.h:4427
# GL/glext.h:4433
glColorMaski = _link_function('glColorMaski', None, [GLuint, GLboolean, GLboolean, GLboolean, GLboolean], 'VERSION_3_0')
# GL/glext.h:4434
glGetBooleani_v = _link_function('glGetBooleani_v', None, [GLenum, GLuint, POINTER(GLboolean)], 'VERSION_3_0')
# GL/glext.h:4435
glGetIntegeri_v = _link_function('glGetIntegeri_v', None, [GLenum, GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4436
glEnablei = _link_function('glEnablei', None, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:4437
glDisablei = _link_function('glDisablei', None, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:4438
glIsEnabledi = _link_function('glIsEnabledi', GLboolean, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:4439
glBeginTransformFeedback = _link_function('glBeginTransformFeedback', None, [GLenum], 'VERSION_3_0')
# GL/glext.h:4440
glEndTransformFeedback = _link_function('glEndTransformFeedback', None, [], 'VERSION_3_0')
# GL/glext.h:4441
glBindBufferRange = _link_function('glBindBufferRange', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'VERSION_3_0')
# GL/glext.h:4442
glBindBufferBase = _link_function('glBindBufferBase', None, [GLenum, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4443
glTransformFeedbackVaryings = _link_function('glTransformFeedbackVaryings', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum], 'VERSION_3_0')
# GL/glext.h:4444
glGetTransformFeedbackVarying = _link_function('glGetTransformFeedbackVarying', None, [GLuint, GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4445
glClampColor = _link_function('glClampColor', None, [GLenum, GLenum], 'VERSION_3_0')
# GL/glext.h:4446
glBeginConditionalRender = _link_function('glBeginConditionalRender', None, [GLuint, GLenum], 'VERSION_3_0')
# GL/glext.h:4447
glEndConditionalRender = _link_function('glEndConditionalRender', None, [], 'VERSION_3_0')
# GL/glext.h:4448
glVertexAttribI1i = _link_function('glVertexAttribI1i', None, [GLuint, GLint], 'VERSION_3_0')
# GL/glext.h:4449
glVertexAttribI2i = _link_function('glVertexAttribI2i', None, [GLuint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:4450
glVertexAttribI3i = _link_function('glVertexAttribI3i', None, [GLuint, GLint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:4451
glVertexAttribI4i = _link_function('glVertexAttribI4i', None, [GLuint, GLint, GLint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:4452
glVertexAttribI1ui = _link_function('glVertexAttribI1ui', None, [GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4453
glVertexAttribI2ui = _link_function('glVertexAttribI2ui', None, [GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4454
glVertexAttribI3ui = _link_function('glVertexAttribI3ui', None, [GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4455
glVertexAttribI4ui = _link_function('glVertexAttribI4ui', None, [GLuint, GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4456
glVertexAttribI1iv = _link_function('glVertexAttribI1iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4457
glVertexAttribI2iv = _link_function('glVertexAttribI2iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4458
glVertexAttribI3iv = _link_function('glVertexAttribI3iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4459
glVertexAttribI4iv = _link_function('glVertexAttribI4iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4460
glVertexAttribI1uiv = _link_function('glVertexAttribI1uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4461
glVertexAttribI2uiv = _link_function('glVertexAttribI2uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4462
glVertexAttribI3uiv = _link_function('glVertexAttribI3uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4463
glVertexAttribI4uiv = _link_function('glVertexAttribI4uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4464
glVertexAttribI4bv = _link_function('glVertexAttribI4bv', None, [GLuint, POINTER(GLbyte)], 'VERSION_3_0')
# GL/glext.h:4465
glVertexAttribI4sv = _link_function('glVertexAttribI4sv', None, [GLuint, POINTER(GLshort)], 'VERSION_3_0')
# GL/glext.h:4466
glVertexAttribI4ubv = _link_function('glVertexAttribI4ubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_3_0')
# GL/glext.h:4467
glVertexAttribI4usv = _link_function('glVertexAttribI4usv', None, [GLuint, POINTER(GLushort)], 'VERSION_3_0')
# GL/glext.h:4468
glVertexAttribIPointer = _link_function('glVertexAttribIPointer', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_3_0')
# GL/glext.h:4469
glGetVertexAttribIiv = _link_function('glGetVertexAttribIiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4470
glGetVertexAttribIuiv = _link_function('glGetVertexAttribIuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4471
glGetUniformuiv = _link_function('glGetUniformuiv', None, [GLuint, GLint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4472
glBindFragDataLocation = _link_function('glBindFragDataLocation', None, [GLuint, GLuint, POINTER(GLchar)], 'VERSION_3_0')
# GL/glext.h:4473
glGetFragDataLocation = _link_function('glGetFragDataLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_3_0')
# GL/glext.h:4474
glUniform1ui = _link_function('glUniform1ui', None, [GLint, GLuint], 'VERSION_3_0')
# GL/glext.h:4475
glUniform2ui = _link_function('glUniform2ui', None, [GLint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4476
glUniform3ui = _link_function('glUniform3ui', None, [GLint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4477
glUniform4ui = _link_function('glUniform4ui', None, [GLint, GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:4478
glUniform1uiv = _link_function('glUniform1uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4479
glUniform2uiv = _link_function('glUniform2uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4480
glUniform3uiv = _link_function('glUniform3uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4481
glUniform4uiv = _link_function('glUniform4uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4482
glTexParameterIiv = _link_function('glTexParameterIiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4483
glTexParameterIuiv = _link_function('glTexParameterIuiv', None, [GLenum, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4484
glGetTexParameterIiv = _link_function('glGetTexParameterIiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4485
glGetTexParameterIuiv = _link_function('glGetTexParameterIuiv', None, [GLenum, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4486
glClearBufferiv = _link_function('glClearBufferiv', None, [GLenum, GLint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:4487
glClearBufferuiv = _link_function('glClearBufferuiv', None, [GLenum, GLint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:4488
glClearBufferfv = _link_function('glClearBufferfv', None, [GLenum, GLint, POINTER(GLfloat)], 'VERSION_3_0')
# GL/glext.h:4489
glClearBufferfi = _link_function('glClearBufferfi', None, [GLenum, GLint, GLfloat, GLint], 'VERSION_3_0')
# GL/glext.h:4490
glGetStringi = _link_function('glGetStringi', POINTER(GLubyte), [GLenum, GLuint], 'VERSION_3_0')
PFNGLCOLORMASKIPROC = CFUNCTYPE(None, GLuint, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:4492
PFNGLGETBOOLEANI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLboolean)) # GL/glext.h:4493
PFNGLGETINTEGERI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:4494
PFNGLENABLEIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4495
PFNGLDISABLEIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4496
PFNGLISENABLEDIPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:4497
PFNGLBEGINTRANSFORMFEEDBACKPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:4498
PFNGLENDTRANSFORMFEEDBACKPROC = CFUNCTYPE(None) # GL/glext.h:4499
PFNGLBINDBUFFERRANGEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:4500
PFNGLBINDBUFFERBASEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:4501
PFNGLTRANSFORMFEEDBACKVARYINGSPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLint), GLenum) # GL/glext.h:4502
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLint)) # GL/glext.h:4503
PFNGLCLAMPCOLORPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:4504
PFNGLBEGINCONDITIONALRENDERPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:4505
PFNGLENDCONDITIONALRENDERPROC = CFUNCTYPE(None) # GL/glext.h:4506
PFNGLVERTEXATTRIBI1IPROC = CFUNCTYPE(None, GLuint, GLint) # GL/glext.h:4507
PFNGLVERTEXATTRIBI2IPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:4508
PFNGLVERTEXATTRIBI3IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:4509
PFNGLVERTEXATTRIBI4IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:4510
PFNGLVERTEXATTRIBI1UIPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:4511
PFNGLVERTEXATTRIBI2UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:4512
PFNGLVERTEXATTRIBI3UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:4513
PFNGLVERTEXATTRIBI4UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:4514
PFNGLVERTEXATTRIBI1IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4515
PFNGLVERTEXATTRIBI2IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4516
PFNGLVERTEXATTRIBI3IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4517
PFNGLVERTEXATTRIBI4IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4518
PFNGLVERTEXATTRIBI1UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4519
PFNGLVERTEXATTRIBI2UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4520
PFNGLVERTEXATTRIBI3UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4521
PFNGLVERTEXATTRIBI4UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4522
PFNGLVERTEXATTRIBI4BVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:4523
PFNGLVERTEXATTRIBI4SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4524
PFNGLVERTEXATTRIBI4UBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:4525
PFNGLVERTEXATTRIBI4USVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:4526
PFNGLVERTEXATTRIBIPOINTERPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4527
PFNGLGETVERTEXATTRIBIIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4528
PFNGLGETVERTEXATTRIBIUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:4529
PFNGLGETUNIFORMUIVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint)) # GL/glext.h:4530
PFNGLBINDFRAGDATALOCATIONPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:4531
PFNGLGETFRAGDATALOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:4532
PFNGLUNIFORM1UIPROC = CFUNCTYPE(None, GLint, GLuint) # GL/glext.h:4533
PFNGLUNIFORM2UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint) # GL/glext.h:4534
PFNGLUNIFORM3UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint) # GL/glext.h:4535
PFNGLUNIFORM4UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:4536
PFNGLUNIFORM1UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:4537
PFNGLUNIFORM2UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:4538
PFNGLUNIFORM3UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:4539
PFNGLUNIFORM4UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:4540
PFNGLTEXPARAMETERIIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4541
PFNGLTEXPARAMETERIUIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:4542
PFNGLGETTEXPARAMETERIIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4543
PFNGLGETTEXPARAMETERIUIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:4544
PFNGLCLEARBUFFERIVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLint)) # GL/glext.h:4545
PFNGLCLEARBUFFERUIVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLuint)) # GL/glext.h:4546
PFNGLCLEARBUFFERFVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLfloat)) # GL/glext.h:4547
PFNGLCLEARBUFFERFIPROC = CFUNCTYPE(None, GLenum, GLint, GLfloat, GLint) # GL/glext.h:4548
PFNGLGETSTRINGIPROC = CFUNCTYPE(POINTER(GLubyte), GLenum, GLuint) # GL/glext.h:4549
# ARB_multitexture (GL/glext.h:4552)
# ARB_transpose_matrix (GL/glext.h:4626)
GL_ARB_transpose_matrix = 1 # GL/glext.h:4627
# GL/glext.h:4629
glLoadTransposeMatrixfARB = _link_function('glLoadTransposeMatrixfARB', None, [POINTER(GLfloat)], 'ARB_transpose_matrix')
# GL/glext.h:4630
glLoadTransposeMatrixdARB = _link_function('glLoadTransposeMatrixdARB', None, [POINTER(GLdouble)], 'ARB_transpose_matrix')
# GL/glext.h:4631
glMultTransposeMatrixfARB = _link_function('glMultTransposeMatrixfARB', None, [POINTER(GLfloat)], 'ARB_transpose_matrix')
# GL/glext.h:4632
glMultTransposeMatrixdARB = _link_function('glMultTransposeMatrixdARB', None, [POINTER(GLdouble)], 'ARB_transpose_matrix')
PFNGLLOADTRANSPOSEMATRIXFARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4634
PFNGLLOADTRANSPOSEMATRIXDARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4635
PFNGLMULTTRANSPOSEMATRIXFARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4636
PFNGLMULTTRANSPOSEMATRIXDARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4637
# ARB_multisample (GL/glext.h:4640)
GL_ARB_multisample = 1 # GL/glext.h:4641
GLclampf = c_float # /usr/include/GL/gl.h:161
# GL/glext.h:4643
glSampleCoverageARB = _link_function('glSampleCoverageARB', None, [GLclampf, GLboolean], 'ARB_multisample')
PFNGLSAMPLECOVERAGEARBPROC = CFUNCTYPE(None, GLclampf, GLboolean) # GL/glext.h:4645
# ARB_texture_env_add (GL/glext.h:4648)
GL_ARB_texture_env_add = 1 # GL/glext.h:4649
# ARB_texture_cube_map (GL/glext.h:4652)
GL_ARB_texture_cube_map = 1 # GL/glext.h:4653
# ARB_texture_compression (GL/glext.h:4656)
GL_ARB_texture_compression = 1 # GL/glext.h:4657
# GL/glext.h:4659
glCompressedTexImage3DARB = _link_function('glCompressedTexImage3DARB', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4660
glCompressedTexImage2DARB = _link_function('glCompressedTexImage2DARB', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4661
glCompressedTexImage1DARB = _link_function('glCompressedTexImage1DARB', None, [GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4662
glCompressedTexSubImage3DARB = _link_function('glCompressedTexSubImage3DARB', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4663
glCompressedTexSubImage2DARB = _link_function('glCompressedTexSubImage2DARB', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4664
glCompressedTexSubImage1DARB = _link_function('glCompressedTexSubImage1DARB', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:4665
glGetCompressedTexImageARB = _link_function('glGetCompressedTexImageARB', None, [GLenum, GLint, POINTER(GLvoid)], 'ARB_texture_compression')
PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:4667
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:4668
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:4669
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4670
PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4671
PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4672
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:4673
# ARB_texture_border_clamp (GL/glext.h:4676)
GL_ARB_texture_border_clamp = 1 # GL/glext.h:4677
# ARB_point_parameters (GL/glext.h:4680)
GL_ARB_point_parameters = 1 # GL/glext.h:4681
# GL/glext.h:4683
glPointParameterfARB = _link_function('glPointParameterfARB', None, [GLenum, GLfloat], 'ARB_point_parameters')
# GL/glext.h:4684
glPointParameterfvARB = _link_function('glPointParameterfvARB', None, [GLenum, POINTER(GLfloat)], 'ARB_point_parameters')
PFNGLPOINTPARAMETERFARBPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:4686
PFNGLPOINTPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:4687
# ARB_vertex_blend (GL/glext.h:4690)
GL_ARB_vertex_blend = 1 # GL/glext.h:4691
# GL/glext.h:4693
glWeightbvARB = _link_function('glWeightbvARB', None, [GLint, POINTER(GLbyte)], 'ARB_vertex_blend')
# GL/glext.h:4694
glWeightsvARB = _link_function('glWeightsvARB', None, [GLint, POINTER(GLshort)], 'ARB_vertex_blend')
# GL/glext.h:4695
glWeightivARB = _link_function('glWeightivARB', None, [GLint, POINTER(GLint)], 'ARB_vertex_blend')
# GL/glext.h:4696
glWeightfvARB = _link_function('glWeightfvARB', None, [GLint, POINTER(GLfloat)], 'ARB_vertex_blend')
# GL/glext.h:4697
glWeightdvARB = _link_function('glWeightdvARB', None, [GLint, POINTER(GLdouble)], 'ARB_vertex_blend')
# GL/glext.h:4698
glWeightubvARB = _link_function('glWeightubvARB', None, [GLint, POINTER(GLubyte)], 'ARB_vertex_blend')
# GL/glext.h:4699
glWeightusvARB = _link_function('glWeightusvARB', None, [GLint, POINTER(GLushort)], 'ARB_vertex_blend')
# GL/glext.h:4700
glWeightuivARB = _link_function('glWeightuivARB', None, [GLint, POINTER(GLuint)], 'ARB_vertex_blend')
# GL/glext.h:4701
glWeightPointerARB = _link_function('glWeightPointerARB', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_vertex_blend')
# GL/glext.h:4702
glVertexBlendARB = _link_function('glVertexBlendARB', None, [GLint], 'ARB_vertex_blend')
PFNGLWEIGHTBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLbyte)) # GL/glext.h:4704
PFNGLWEIGHTSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLshort)) # GL/glext.h:4705
PFNGLWEIGHTIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLint)) # GL/glext.h:4706
PFNGLWEIGHTFVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLfloat)) # GL/glext.h:4707
PFNGLWEIGHTDVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLdouble)) # GL/glext.h:4708
PFNGLWEIGHTUBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLubyte)) # GL/glext.h:4709
PFNGLWEIGHTUSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLushort)) # GL/glext.h:4710
PFNGLWEIGHTUIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLuint)) # GL/glext.h:4711
PFNGLWEIGHTPOINTERARBPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4712
PFNGLVERTEXBLENDARBPROC = CFUNCTYPE(None, GLint) # GL/glext.h:4713
# ARB_matrix_palette (GL/glext.h:4716)
GL_ARB_matrix_palette = 1 # GL/glext.h:4717
# GL/glext.h:4719
glCurrentPaletteMatrixARB = _link_function('glCurrentPaletteMatrixARB', None, [GLint], 'ARB_matrix_palette')
# GL/glext.h:4720
glMatrixIndexubvARB = _link_function('glMatrixIndexubvARB', None, [GLint, POINTER(GLubyte)], 'ARB_matrix_palette')
# GL/glext.h:4721
glMatrixIndexusvARB = _link_function('glMatrixIndexusvARB', None, [GLint, POINTER(GLushort)], 'ARB_matrix_palette')
# GL/glext.h:4722
glMatrixIndexuivARB = _link_function('glMatrixIndexuivARB', None, [GLint, POINTER(GLuint)], 'ARB_matrix_palette')
# GL/glext.h:4723
glMatrixIndexPointerARB = _link_function('glMatrixIndexPointerARB', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_matrix_palette')
PFNGLCURRENTPALETTEMATRIXARBPROC = CFUNCTYPE(None, GLint) # GL/glext.h:4725
PFNGLMATRIXINDEXUBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLubyte)) # GL/glext.h:4726
PFNGLMATRIXINDEXUSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLushort)) # GL/glext.h:4727
PFNGLMATRIXINDEXUIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLuint)) # GL/glext.h:4728
PFNGLMATRIXINDEXPOINTERARBPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4729
# ARB_texture_env_combine (GL/glext.h:4732)
GL_ARB_texture_env_combine = 1 # GL/glext.h:4733
# ARB_texture_env_crossbar (GL/glext.h:4736)
GL_ARB_texture_env_crossbar = 1 # GL/glext.h:4737
# ARB_texture_env_dot3 (GL/glext.h:4740)
GL_ARB_texture_env_dot3 = 1 # GL/glext.h:4741
# ARB_texture_mirrored_repeat (GL/glext.h:4744)
GL_ARB_texture_mirrored_repeat = 1 # GL/glext.h:4745
# ARB_depth_texture (GL/glext.h:4748)
GL_ARB_depth_texture = 1 # GL/glext.h:4749
# ARB_shadow (GL/glext.h:4752)
GL_ARB_shadow = 1 # GL/glext.h:4753
# ARB_shadow_ambient (GL/glext.h:4756)
GL_ARB_shadow_ambient = 1 # GL/glext.h:4757
# ARB_window_pos (GL/glext.h:4760)
GL_ARB_window_pos = 1 # GL/glext.h:4761
# GL/glext.h:4763
glWindowPos2dARB = _link_function('glWindowPos2dARB', None, [GLdouble, GLdouble], 'ARB_window_pos')
# GL/glext.h:4764
glWindowPos2dvARB = _link_function('glWindowPos2dvARB', None, [POINTER(GLdouble)], 'ARB_window_pos')
# GL/glext.h:4765
glWindowPos2fARB = _link_function('glWindowPos2fARB', None, [GLfloat, GLfloat], 'ARB_window_pos')
# GL/glext.h:4766
glWindowPos2fvARB = _link_function('glWindowPos2fvARB', None, [POINTER(GLfloat)], 'ARB_window_pos')
# GL/glext.h:4767
glWindowPos2iARB = _link_function('glWindowPos2iARB', None, [GLint, GLint], 'ARB_window_pos')
# GL/glext.h:4768
glWindowPos2ivARB = _link_function('glWindowPos2ivARB', None, [POINTER(GLint)], 'ARB_window_pos')
# GL/glext.h:4769
glWindowPos2sARB = _link_function('glWindowPos2sARB', None, [GLshort, GLshort], 'ARB_window_pos')
# GL/glext.h:4770
glWindowPos2svARB = _link_function('glWindowPos2svARB', None, [POINTER(GLshort)], 'ARB_window_pos')
# GL/glext.h:4771
glWindowPos3dARB = _link_function('glWindowPos3dARB', None, [GLdouble, GLdouble, GLdouble], 'ARB_window_pos')
# GL/glext.h:4772
glWindowPos3dvARB = _link_function('glWindowPos3dvARB', None, [POINTER(GLdouble)], 'ARB_window_pos')
# GL/glext.h:4773
glWindowPos3fARB = _link_function('glWindowPos3fARB', None, [GLfloat, GLfloat, GLfloat], 'ARB_window_pos')
# GL/glext.h:4774
glWindowPos3fvARB = _link_function('glWindowPos3fvARB', None, [POINTER(GLfloat)], 'ARB_window_pos')
# GL/glext.h:4775
glWindowPos3iARB = _link_function('glWindowPos3iARB', None, [GLint, GLint, GLint], 'ARB_window_pos')
# GL/glext.h:4776
glWindowPos3ivARB = _link_function('glWindowPos3ivARB', None, [POINTER(GLint)], 'ARB_window_pos')
# GL/glext.h:4777
glWindowPos3sARB = _link_function('glWindowPos3sARB', None, [GLshort, GLshort, GLshort], 'ARB_window_pos')
# GL/glext.h:4778
glWindowPos3svARB = _link_function('glWindowPos3svARB', None, [POINTER(GLshort)], 'ARB_window_pos')
PFNGLWINDOWPOS2DARBPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:4780
PFNGLWINDOWPOS2DVARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4781
PFNGLWINDOWPOS2FARBPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:4782
PFNGLWINDOWPOS2FVARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4783
PFNGLWINDOWPOS2IARBPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:4784
PFNGLWINDOWPOS2IVARBPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:4785
PFNGLWINDOWPOS2SARBPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:4786
PFNGLWINDOWPOS2SVARBPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:4787
PFNGLWINDOWPOS3DARBPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:4788
PFNGLWINDOWPOS3DVARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:4789
PFNGLWINDOWPOS3FARBPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:4790
PFNGLWINDOWPOS3FVARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:4791
PFNGLWINDOWPOS3IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:4792
PFNGLWINDOWPOS3IVARBPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:4793
PFNGLWINDOWPOS3SARBPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:4794
PFNGLWINDOWPOS3SVARBPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:4795
# ARB_vertex_program (GL/glext.h:4798)
GL_ARB_vertex_program = 1 # GL/glext.h:4799
# GL/glext.h:4801
glVertexAttrib1dARB = _link_function('glVertexAttrib1dARB', None, [GLuint, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4802
glVertexAttrib1dvARB = _link_function('glVertexAttrib1dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4803
glVertexAttrib1fARB = _link_function('glVertexAttrib1fARB', None, [GLuint, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4804
glVertexAttrib1fvARB = _link_function('glVertexAttrib1fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4805
glVertexAttrib1sARB = _link_function('glVertexAttrib1sARB', None, [GLuint, GLshort], 'ARB_vertex_program')
# GL/glext.h:4806
glVertexAttrib1svARB = _link_function('glVertexAttrib1svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:4807
glVertexAttrib2dARB = _link_function('glVertexAttrib2dARB', None, [GLuint, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4808
glVertexAttrib2dvARB = _link_function('glVertexAttrib2dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4809
glVertexAttrib2fARB = _link_function('glVertexAttrib2fARB', None, [GLuint, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4810
glVertexAttrib2fvARB = _link_function('glVertexAttrib2fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4811
glVertexAttrib2sARB = _link_function('glVertexAttrib2sARB', None, [GLuint, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:4812
glVertexAttrib2svARB = _link_function('glVertexAttrib2svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:4813
glVertexAttrib3dARB = _link_function('glVertexAttrib3dARB', None, [GLuint, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4814
glVertexAttrib3dvARB = _link_function('glVertexAttrib3dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4815
glVertexAttrib3fARB = _link_function('glVertexAttrib3fARB', None, [GLuint, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4816
glVertexAttrib3fvARB = _link_function('glVertexAttrib3fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4817
glVertexAttrib3sARB = _link_function('glVertexAttrib3sARB', None, [GLuint, GLshort, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:4818
glVertexAttrib3svARB = _link_function('glVertexAttrib3svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:4819
glVertexAttrib4NbvARB = _link_function('glVertexAttrib4NbvARB', None, [GLuint, POINTER(GLbyte)], 'ARB_vertex_program')
# GL/glext.h:4820
glVertexAttrib4NivARB = _link_function('glVertexAttrib4NivARB', None, [GLuint, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:4821
glVertexAttrib4NsvARB = _link_function('glVertexAttrib4NsvARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:4822
glVertexAttrib4NubARB = _link_function('glVertexAttrib4NubARB', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'ARB_vertex_program')
# GL/glext.h:4823
glVertexAttrib4NubvARB = _link_function('glVertexAttrib4NubvARB', None, [GLuint, POINTER(GLubyte)], 'ARB_vertex_program')
# GL/glext.h:4824
glVertexAttrib4NuivARB = _link_function('glVertexAttrib4NuivARB', None, [GLuint, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:4825
glVertexAttrib4NusvARB = _link_function('glVertexAttrib4NusvARB', None, [GLuint, POINTER(GLushort)], 'ARB_vertex_program')
# GL/glext.h:4826
glVertexAttrib4bvARB = _link_function('glVertexAttrib4bvARB', None, [GLuint, POINTER(GLbyte)], 'ARB_vertex_program')
# GL/glext.h:4827
glVertexAttrib4dARB = _link_function('glVertexAttrib4dARB', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4828
glVertexAttrib4dvARB = _link_function('glVertexAttrib4dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4829
glVertexAttrib4fARB = _link_function('glVertexAttrib4fARB', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4830
glVertexAttrib4fvARB = _link_function('glVertexAttrib4fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4831
glVertexAttrib4ivARB = _link_function('glVertexAttrib4ivARB', None, [GLuint, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:4832
glVertexAttrib4sARB = _link_function('glVertexAttrib4sARB', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:4833
glVertexAttrib4svARB = _link_function('glVertexAttrib4svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:4834
glVertexAttrib4ubvARB = _link_function('glVertexAttrib4ubvARB', None, [GLuint, POINTER(GLubyte)], 'ARB_vertex_program')
# GL/glext.h:4835
glVertexAttrib4uivARB = _link_function('glVertexAttrib4uivARB', None, [GLuint, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:4836
glVertexAttrib4usvARB = _link_function('glVertexAttrib4usvARB', None, [GLuint, POINTER(GLushort)], 'ARB_vertex_program')
# GL/glext.h:4837
glVertexAttribPointerARB = _link_function('glVertexAttribPointerARB', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:4838
glEnableVertexAttribArrayARB = _link_function('glEnableVertexAttribArrayARB', None, [GLuint], 'ARB_vertex_program')
# GL/glext.h:4839
glDisableVertexAttribArrayARB = _link_function('glDisableVertexAttribArrayARB', None, [GLuint], 'ARB_vertex_program')
# GL/glext.h:4840
glProgramStringARB = _link_function('glProgramStringARB', None, [GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:4841
glBindProgramARB = _link_function('glBindProgramARB', None, [GLenum, GLuint], 'ARB_vertex_program')
# GL/glext.h:4842
glDeleteProgramsARB = _link_function('glDeleteProgramsARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:4843
glGenProgramsARB = _link_function('glGenProgramsARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:4844
glProgramEnvParameter4dARB = _link_function('glProgramEnvParameter4dARB', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4845
glProgramEnvParameter4dvARB = _link_function('glProgramEnvParameter4dvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4846
glProgramEnvParameter4fARB = _link_function('glProgramEnvParameter4fARB', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4847
glProgramEnvParameter4fvARB = _link_function('glProgramEnvParameter4fvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4848
glProgramLocalParameter4dARB = _link_function('glProgramLocalParameter4dARB', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:4849
glProgramLocalParameter4dvARB = _link_function('glProgramLocalParameter4dvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4850
glProgramLocalParameter4fARB = _link_function('glProgramLocalParameter4fARB', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:4851
glProgramLocalParameter4fvARB = _link_function('glProgramLocalParameter4fvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4852
glGetProgramEnvParameterdvARB = _link_function('glGetProgramEnvParameterdvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4853
glGetProgramEnvParameterfvARB = _link_function('glGetProgramEnvParameterfvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4854
glGetProgramLocalParameterdvARB = _link_function('glGetProgramLocalParameterdvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4855
glGetProgramLocalParameterfvARB = _link_function('glGetProgramLocalParameterfvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4856
glGetProgramivARB = _link_function('glGetProgramivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:4857
glGetProgramStringARB = _link_function('glGetProgramStringARB', None, [GLenum, GLenum, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:4858
glGetVertexAttribdvARB = _link_function('glGetVertexAttribdvARB', None, [GLuint, GLenum, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:4859
glGetVertexAttribfvARB = _link_function('glGetVertexAttribfvARB', None, [GLuint, GLenum, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:4860
glGetVertexAttribivARB = _link_function('glGetVertexAttribivARB', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:4861
glGetVertexAttribPointervARB = _link_function('glGetVertexAttribPointervARB', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'ARB_vertex_program')
# GL/glext.h:4862
glIsProgramARB = _link_function('glIsProgramARB', GLboolean, [GLuint], 'ARB_vertex_program')
PFNGLVERTEXATTRIB1DARBPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:4864
PFNGLVERTEXATTRIB1DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4865
PFNGLVERTEXATTRIB1FARBPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:4866
PFNGLVERTEXATTRIB1FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4867
PFNGLVERTEXATTRIB1SARBPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:4868
PFNGLVERTEXATTRIB1SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4869
PFNGLVERTEXATTRIB2DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:4870
PFNGLVERTEXATTRIB2DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4871
PFNGLVERTEXATTRIB2FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:4872
PFNGLVERTEXATTRIB2FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4873
PFNGLVERTEXATTRIB2SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:4874
PFNGLVERTEXATTRIB2SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4875
PFNGLVERTEXATTRIB3DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:4876
PFNGLVERTEXATTRIB3DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4877
PFNGLVERTEXATTRIB3FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:4878
PFNGLVERTEXATTRIB3FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4879
PFNGLVERTEXATTRIB3SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:4880
PFNGLVERTEXATTRIB3SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4881
PFNGLVERTEXATTRIB4NBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:4882
PFNGLVERTEXATTRIB4NIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4883
PFNGLVERTEXATTRIB4NSVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4884
PFNGLVERTEXATTRIB4NUBARBPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:4885
PFNGLVERTEXATTRIB4NUBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:4886
PFNGLVERTEXATTRIB4NUIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4887
PFNGLVERTEXATTRIB4NUSVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:4888
PFNGLVERTEXATTRIB4BVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:4889
PFNGLVERTEXATTRIB4DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:4890
PFNGLVERTEXATTRIB4DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:4891
PFNGLVERTEXATTRIB4FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:4892
PFNGLVERTEXATTRIB4FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:4893
PFNGLVERTEXATTRIB4IVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:4894
PFNGLVERTEXATTRIB4SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:4895
PFNGLVERTEXATTRIB4SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:4896
PFNGLVERTEXATTRIB4UBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:4897
PFNGLVERTEXATTRIB4UIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:4898
PFNGLVERTEXATTRIB4USVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:4899
PFNGLVERTEXATTRIBPOINTERARBPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)) # GL/glext.h:4900
PFNGLENABLEVERTEXATTRIBARRAYARBPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4901
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:4902
PFNGLPROGRAMSTRINGARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:4903
PFNGLBINDPROGRAMARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4904
PFNGLDELETEPROGRAMSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4905
PFNGLGENPROGRAMSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4906
PFNGLPROGRAMENVPARAMETER4DARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:4907
PFNGLPROGRAMENVPARAMETER4DVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:4908
PFNGLPROGRAMENVPARAMETER4FARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:4909
PFNGLPROGRAMENVPARAMETER4FVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:4910
PFNGLPROGRAMLOCALPARAMETER4DARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:4911
PFNGLPROGRAMLOCALPARAMETER4DVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:4912
PFNGLPROGRAMLOCALPARAMETER4FARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:4913
PFNGLPROGRAMLOCALPARAMETER4FVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:4914
PFNGLGETPROGRAMENVPARAMETERDVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:4915
PFNGLGETPROGRAMENVPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:4916
PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:4917
PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:4918
PFNGLGETPROGRAMIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4919
PFNGLGETPROGRAMSTRINGARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:4920
PFNGLGETVERTEXATTRIBDVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:4921
PFNGLGETVERTEXATTRIBFVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:4922
PFNGLGETVERTEXATTRIBIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4923
PFNGLGETVERTEXATTRIBPOINTERVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:4924
PFNGLISPROGRAMARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4925
# ARB_fragment_program (GL/glext.h:4928)
GL_ARB_fragment_program = 1 # GL/glext.h:4929
# ARB_vertex_buffer_object (GL/glext.h:4933)
GL_ARB_vertex_buffer_object = 1 # GL/glext.h:4934
# GL/glext.h:4936
glBindBufferARB = _link_function('glBindBufferARB', None, [GLenum, GLuint], 'ARB_vertex_buffer_object')
# GL/glext.h:4937
glDeleteBuffersARB = _link_function('glDeleteBuffersARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_buffer_object')
# GL/glext.h:4938
glGenBuffersARB = _link_function('glGenBuffersARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_buffer_object')
# GL/glext.h:4939
glIsBufferARB = _link_function('glIsBufferARB', GLboolean, [GLuint], 'ARB_vertex_buffer_object')
# GL/glext.h:4940
glBufferDataARB = _link_function('glBufferDataARB', None, [GLenum, GLsizeiptrARB, POINTER(GLvoid), GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:4941
glBufferSubDataARB = _link_function('glBufferSubDataARB', None, [GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)], 'ARB_vertex_buffer_object')
# GL/glext.h:4942
glGetBufferSubDataARB = _link_function('glGetBufferSubDataARB', None, [GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)], 'ARB_vertex_buffer_object')
# GL/glext.h:4943
glMapBufferARB = _link_function('glMapBufferARB', POINTER(GLvoid), [GLenum, GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:4944
glUnmapBufferARB = _link_function('glUnmapBufferARB', GLboolean, [GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:4945
glGetBufferParameterivARB = _link_function('glGetBufferParameterivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_vertex_buffer_object')
# GL/glext.h:4946
glGetBufferPointervARB = _link_function('glGetBufferPointervARB', None, [GLenum, GLenum, POINTER(POINTER(GLvoid))], 'ARB_vertex_buffer_object')
PFNGLBINDBUFFERARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4948
PFNGLDELETEBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4949
PFNGLGENBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4950
PFNGLISBUFFERARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4951
PFNGLBUFFERDATAARBPROC = CFUNCTYPE(None, GLenum, GLsizeiptrARB, POINTER(GLvoid), GLenum) # GL/glext.h:4952
PFNGLBUFFERSUBDATAARBPROC = CFUNCTYPE(None, GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)) # GL/glext.h:4953
PFNGLGETBUFFERSUBDATAARBPROC = CFUNCTYPE(None, GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)) # GL/glext.h:4954
PFNGLMAPBUFFERARBPROC = CFUNCTYPE(POINTER(GLvoid), GLenum, GLenum) # GL/glext.h:4955
PFNGLUNMAPBUFFERARBPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:4956
PFNGLGETBUFFERPARAMETERIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4957
PFNGLGETBUFFERPOINTERVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:4958
# ARB_occlusion_query (GL/glext.h:4961)
GL_ARB_occlusion_query = 1 # GL/glext.h:4962
# GL/glext.h:4964
glGenQueriesARB = _link_function('glGenQueriesARB', None, [GLsizei, POINTER(GLuint)], 'ARB_occlusion_query')
# GL/glext.h:4965
glDeleteQueriesARB = _link_function('glDeleteQueriesARB', None, [GLsizei, POINTER(GLuint)], 'ARB_occlusion_query')
# GL/glext.h:4966
glIsQueryARB = _link_function('glIsQueryARB', GLboolean, [GLuint], 'ARB_occlusion_query')
# GL/glext.h:4967
glBeginQueryARB = _link_function('glBeginQueryARB', None, [GLenum, GLuint], 'ARB_occlusion_query')
# GL/glext.h:4968
glEndQueryARB = _link_function('glEndQueryARB', None, [GLenum], 'ARB_occlusion_query')
# GL/glext.h:4969
glGetQueryivARB = _link_function('glGetQueryivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_occlusion_query')
# GL/glext.h:4970
glGetQueryObjectivARB = _link_function('glGetQueryObjectivARB', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_occlusion_query')
# GL/glext.h:4971
glGetQueryObjectuivARB = _link_function('glGetQueryObjectuivARB', None, [GLuint, GLenum, POINTER(GLuint)], 'ARB_occlusion_query')
PFNGLGENQUERIESARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4973
PFNGLDELETEQUERIESARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:4974
PFNGLISQUERYARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:4975
PFNGLBEGINQUERYARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:4976
PFNGLENDQUERYARBPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:4977
PFNGLGETQUERYIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:4978
PFNGLGETQUERYOBJECTIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:4979
PFNGLGETQUERYOBJECTUIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:4980
# ARB_shader_objects (GL/glext.h:4983)
GL_ARB_shader_objects = 1 # GL/glext.h:4984
# GL/glext.h:4986
glDeleteObjectARB = _link_function('glDeleteObjectARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4987
glGetHandleARB = _link_function('glGetHandleARB', GLhandleARB, [GLenum], 'ARB_shader_objects')
# GL/glext.h:4988
glDetachObjectARB = _link_function('glDetachObjectARB', None, [GLhandleARB, GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4989
glCreateShaderObjectARB = _link_function('glCreateShaderObjectARB', GLhandleARB, [GLenum], 'ARB_shader_objects')
# GL/glext.h:4990
glShaderSourceARB = _link_function('glShaderSourceARB', None, [GLhandleARB, GLsizei, POINTER(POINTER(GLcharARB)), POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:4991
glCompileShaderARB = _link_function('glCompileShaderARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4992
glCreateProgramObjectARB = _link_function('glCreateProgramObjectARB', GLhandleARB, [], 'ARB_shader_objects')
# GL/glext.h:4993
glAttachObjectARB = _link_function('glAttachObjectARB', None, [GLhandleARB, GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4994
glLinkProgramARB = _link_function('glLinkProgramARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4995
glUseProgramObjectARB = _link_function('glUseProgramObjectARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4996
glValidateProgramARB = _link_function('glValidateProgramARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:4997
glUniform1fARB = _link_function('glUniform1fARB', None, [GLint, GLfloat], 'ARB_shader_objects')
# GL/glext.h:4998
glUniform2fARB = _link_function('glUniform2fARB', None, [GLint, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:4999
glUniform3fARB = _link_function('glUniform3fARB', None, [GLint, GLfloat, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:5000
glUniform4fARB = _link_function('glUniform4fARB', None, [GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:5001
glUniform1iARB = _link_function('glUniform1iARB', None, [GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:5002
glUniform2iARB = _link_function('glUniform2iARB', None, [GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:5003
glUniform3iARB = _link_function('glUniform3iARB', None, [GLint, GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:5004
glUniform4iARB = _link_function('glUniform4iARB', None, [GLint, GLint, GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:5005
glUniform1fvARB = _link_function('glUniform1fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5006
glUniform2fvARB = _link_function('glUniform2fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5007
glUniform3fvARB = _link_function('glUniform3fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5008
glUniform4fvARB = _link_function('glUniform4fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5009
glUniform1ivARB = _link_function('glUniform1ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5010
glUniform2ivARB = _link_function('glUniform2ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5011
glUniform3ivARB = _link_function('glUniform3ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5012
glUniform4ivARB = _link_function('glUniform4ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5013
glUniformMatrix2fvARB = _link_function('glUniformMatrix2fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5014
glUniformMatrix3fvARB = _link_function('glUniformMatrix3fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5015
glUniformMatrix4fvARB = _link_function('glUniformMatrix4fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5016
glGetObjectParameterfvARB = _link_function('glGetObjectParameterfvARB', None, [GLhandleARB, GLenum, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5017
glGetObjectParameterivARB = _link_function('glGetObjectParameterivARB', None, [GLhandleARB, GLenum, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5018
glGetInfoLogARB = _link_function('glGetInfoLogARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:5019
glGetAttachedObjectsARB = _link_function('glGetAttachedObjectsARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLhandleARB)], 'ARB_shader_objects')
# GL/glext.h:5020
glGetUniformLocationARB = _link_function('glGetUniformLocationARB', GLint, [GLhandleARB, POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:5021
glGetActiveUniformARB = _link_function('glGetActiveUniformARB', None, [GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:5022
glGetUniformfvARB = _link_function('glGetUniformfvARB', None, [GLhandleARB, GLint, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:5023
glGetUniformivARB = _link_function('glGetUniformivARB', None, [GLhandleARB, GLint, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:5024
glGetShaderSourceARB = _link_function('glGetShaderSourceARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)], 'ARB_shader_objects')
PFNGLDELETEOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:5026
PFNGLGETHANDLEARBPROC = CFUNCTYPE(GLhandleARB, GLenum) # GL/glext.h:5027
PFNGLDETACHOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB, GLhandleARB) # GL/glext.h:5028
PFNGLCREATESHADEROBJECTARBPROC = CFUNCTYPE(GLhandleARB, GLenum) # GL/glext.h:5029
PFNGLSHADERSOURCEARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(POINTER(GLcharARB)), POINTER(GLint)) # GL/glext.h:5030
PFNGLCOMPILESHADERARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:5031
PFNGLCREATEPROGRAMOBJECTARBPROC = CFUNCTYPE(GLhandleARB) # GL/glext.h:5032
PFNGLATTACHOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB, GLhandleARB) # GL/glext.h:5033
PFNGLLINKPROGRAMARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:5034
PFNGLUSEPROGRAMOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:5035
PFNGLVALIDATEPROGRAMARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:5036
PFNGLUNIFORM1FARBPROC = CFUNCTYPE(None, GLint, GLfloat) # GL/glext.h:5037
PFNGLUNIFORM2FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat) # GL/glext.h:5038
PFNGLUNIFORM3FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:5039
PFNGLUNIFORM4FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:5040
PFNGLUNIFORM1IARBPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:5041
PFNGLUNIFORM2IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:5042
PFNGLUNIFORM3IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:5043
PFNGLUNIFORM4IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:5044
PFNGLUNIFORM1FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:5045
PFNGLUNIFORM2FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:5046
PFNGLUNIFORM3FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:5047
PFNGLUNIFORM4FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:5048
PFNGLUNIFORM1IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:5049
PFNGLUNIFORM2IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:5050
PFNGLUNIFORM3IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:5051
PFNGLUNIFORM4IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:5052
PFNGLUNIFORMMATRIX2FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:5053
PFNGLUNIFORMMATRIX3FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:5054
PFNGLUNIFORMMATRIX4FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:5055
PFNGLGETOBJECTPARAMETERFVARBPROC = CFUNCTYPE(None, GLhandleARB, GLenum, POINTER(GLfloat)) # GL/glext.h:5056
PFNGLGETOBJECTPARAMETERIVARBPROC = CFUNCTYPE(None, GLhandleARB, GLenum, POINTER(GLint)) # GL/glext.h:5057
PFNGLGETINFOLOGARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)) # GL/glext.h:5058
PFNGLGETATTACHEDOBJECTSARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLhandleARB)) # GL/glext.h:5059
PFNGLGETUNIFORMLOCATIONARBPROC = CFUNCTYPE(GLint, GLhandleARB, POINTER(GLcharARB)) # GL/glext.h:5060
PFNGLGETACTIVEUNIFORMARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)) # GL/glext.h:5061
PFNGLGETUNIFORMFVARBPROC = CFUNCTYPE(None, GLhandleARB, GLint, POINTER(GLfloat)) # GL/glext.h:5062
PFNGLGETUNIFORMIVARBPROC = CFUNCTYPE(None, GLhandleARB, GLint, POINTER(GLint)) # GL/glext.h:5063
PFNGLGETSHADERSOURCEARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)) # GL/glext.h:5064
# ARB_vertex_shader (GL/glext.h:5067)
GL_ARB_vertex_shader = 1 # GL/glext.h:5068
# GL/glext.h:5070
glBindAttribLocationARB = _link_function('glBindAttribLocationARB', None, [GLhandleARB, GLuint, POINTER(GLcharARB)], 'ARB_vertex_shader')
# GL/glext.h:5071
glGetActiveAttribARB = _link_function('glGetActiveAttribARB', None, [GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)], 'ARB_vertex_shader')
# GL/glext.h:5072
glGetAttribLocationARB = _link_function('glGetAttribLocationARB', GLint, [GLhandleARB, POINTER(GLcharARB)], 'ARB_vertex_shader')
PFNGLBINDATTRIBLOCATIONARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, POINTER(GLcharARB)) # GL/glext.h:5074
PFNGLGETACTIVEATTRIBARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)) # GL/glext.h:5075
PFNGLGETATTRIBLOCATIONARBPROC = CFUNCTYPE(GLint, GLhandleARB, POINTER(GLcharARB)) # GL/glext.h:5076
# ARB_fragment_shader (GL/glext.h:5079)
GL_ARB_fragment_shader = 1 # GL/glext.h:5080
# ARB_shading_language_100 (GL/glext.h:5083)
GL_ARB_shading_language_100 = 1 # GL/glext.h:5084
# ARB_texture_non_power_of_two (GL/glext.h:5087)
GL_ARB_texture_non_power_of_two = 1 # GL/glext.h:5088
# ARB_point_sprite (GL/glext.h:5091)
GL_ARB_point_sprite = 1 # GL/glext.h:5092
# ARB_fragment_program_shadow (GL/glext.h:5095)
GL_ARB_fragment_program_shadow = 1 # GL/glext.h:5096
# ARB_draw_buffers (GL/glext.h:5099)
GL_ARB_draw_buffers = 1 # GL/glext.h:5100
# GL/glext.h:5102
glDrawBuffersARB = _link_function('glDrawBuffersARB', None, [GLsizei, POINTER(GLenum)], 'ARB_draw_buffers')
PFNGLDRAWBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:5104
# ARB_texture_rectangle (GL/glext.h:5107)
GL_ARB_texture_rectangle = 1 # GL/glext.h:5108
# ARB_color_buffer_float (GL/glext.h:5111)
GL_ARB_color_buffer_float = 1 # GL/glext.h:5112
# GL/glext.h:5114
glClampColorARB = _link_function('glClampColorARB', None, [GLenum, GLenum], 'ARB_color_buffer_float')
PFNGLCLAMPCOLORARBPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:5116
# ARB_half_float_pixel (GL/glext.h:5119)
GL_ARB_half_float_pixel = 1 # GL/glext.h:5120
# ARB_texture_float (GL/glext.h:5123)
GL_ARB_texture_float = 1 # GL/glext.h:5124
# ARB_pixel_buffer_object (GL/glext.h:5127)
GL_ARB_pixel_buffer_object = 1 # GL/glext.h:5128
# ARB_depth_buffer_float (GL/glext.h:5131)
GL_ARB_depth_buffer_float = 1 # GL/glext.h:5132
# ARB_draw_instanced (GL/glext.h:5135)
GL_ARB_draw_instanced = 1 # GL/glext.h:5136
# GL/glext.h:5138
glDrawArraysInstancedARB = _link_function('glDrawArraysInstancedARB', None, [GLenum, GLint, GLsizei, GLsizei], 'ARB_draw_instanced')
# GL/glext.h:5139
glDrawElementsInstancedARB = _link_function('glDrawElementsInstancedARB', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei], 'ARB_draw_instanced')
PFNGLDRAWARRAYSINSTANCEDARBPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:5141
PFNGLDRAWELEMENTSINSTANCEDARBPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:5142
# ARB_framebuffer_object (GL/glext.h:5145)
GL_ARB_framebuffer_object = 1 # GL/glext.h:5146
# GL/glext.h:5148
glIsRenderbuffer = _link_function('glIsRenderbuffer', GLboolean, [GLuint], 'ARB_framebuffer_object')
# GL/glext.h:5149
glBindRenderbuffer = _link_function('glBindRenderbuffer', None, [GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:5150
glDeleteRenderbuffers = _link_function('glDeleteRenderbuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:5151
glGenRenderbuffers = _link_function('glGenRenderbuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:5152
glRenderbufferStorage = _link_function('glRenderbufferStorage', None, [GLenum, GLenum, GLsizei, GLsizei], 'ARB_framebuffer_object')
# GL/glext.h:5153
glGetRenderbufferParameteriv = _link_function('glGetRenderbufferParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_framebuffer_object')
# GL/glext.h:5154
glIsFramebuffer = _link_function('glIsFramebuffer', GLboolean, [GLuint], 'ARB_framebuffer_object')
# GL/glext.h:5155
glBindFramebuffer = _link_function('glBindFramebuffer', None, [GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:5156
glDeleteFramebuffers = _link_function('glDeleteFramebuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:5157
glGenFramebuffers = _link_function('glGenFramebuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:5158
glCheckFramebufferStatus = _link_function('glCheckFramebufferStatus', GLenum, [GLenum], 'ARB_framebuffer_object')
# GL/glext.h:5159
glFramebufferTexture1D = _link_function('glFramebufferTexture1D', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:5160
glFramebufferTexture2D = _link_function('glFramebufferTexture2D', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:5161
glFramebufferTexture3D = _link_function('glFramebufferTexture3D', None, [GLenum, GLenum, GLenum, GLuint, GLint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:5162
glFramebufferRenderbuffer = _link_function('glFramebufferRenderbuffer', None, [GLenum, GLenum, GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:5163
glGetFramebufferAttachmentParameteriv = _link_function('glGetFramebufferAttachmentParameteriv', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'ARB_framebuffer_object')
# GL/glext.h:5164
glGenerateMipmap = _link_function('glGenerateMipmap', None, [GLenum], 'ARB_framebuffer_object')
GLbitfield = c_uint # /usr/include/GL/gl.h:151
# GL/glext.h:5165
glBlitFramebuffer = _link_function('glBlitFramebuffer', None, [GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], 'ARB_framebuffer_object')
# GL/glext.h:5166
glRenderbufferStorageMultisample = _link_function('glRenderbufferStorageMultisample', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'ARB_framebuffer_object')
# GL/glext.h:5167
glFramebufferTextureLayer = _link_function('glFramebufferTextureLayer', None, [GLenum, GLenum, GLuint, GLint, GLint], 'ARB_framebuffer_object')
PFNGLISRENDERBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5169
PFNGLBINDRENDERBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:5170
PFNGLDELETERENDERBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5171
PFNGLGENRENDERBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5172
PFNGLRENDERBUFFERSTORAGEPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei) # GL/glext.h:5173
PFNGLGETRENDERBUFFERPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5174
PFNGLISFRAMEBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5175
PFNGLBINDFRAMEBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:5176
PFNGLDELETEFRAMEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5177
PFNGLGENFRAMEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5178
PFNGLCHECKFRAMEBUFFERSTATUSPROC = CFUNCTYPE(GLenum, GLenum) # GL/glext.h:5179
PFNGLFRAMEBUFFERTEXTURE1DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:5180
PFNGLFRAMEBUFFERTEXTURE2DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:5181
PFNGLFRAMEBUFFERTEXTURE3DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:5182
PFNGLFRAMEBUFFERRENDERBUFFERPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:5183
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5184
PFNGLGENERATEMIPMAPPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5185
PFNGLBLITFRAMEBUFFERPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) # GL/glext.h:5186
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:5187
PFNGLFRAMEBUFFERTEXTURELAYERPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:5188
# ARB_framebuffer_sRGB (GL/glext.h:5191)
GL_ARB_framebuffer_sRGB = 1 # GL/glext.h:5192
# ARB_geometry_shader4 (GL/glext.h:5195)
GL_ARB_geometry_shader4 = 1 # GL/glext.h:5196
# GL/glext.h:5198
glProgramParameteriARB = _link_function('glProgramParameteriARB', None, [GLuint, GLenum, GLint], 'ARB_geometry_shader4')
# GL/glext.h:5199
glFramebufferTextureARB = _link_function('glFramebufferTextureARB', None, [GLenum, GLenum, GLuint, GLint], 'ARB_geometry_shader4')
# GL/glext.h:5200
glFramebufferTextureLayerARB = _link_function('glFramebufferTextureLayerARB', None, [GLenum, GLenum, GLuint, GLint, GLint], 'ARB_geometry_shader4')
# GL/glext.h:5201
glFramebufferTextureFaceARB = _link_function('glFramebufferTextureFaceARB', None, [GLenum, GLenum, GLuint, GLint, GLenum], 'ARB_geometry_shader4')
PFNGLPROGRAMPARAMETERIARBPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:5203
PFNGLFRAMEBUFFERTEXTUREARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint) # GL/glext.h:5204
PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:5205
PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLenum) # GL/glext.h:5206
# ARB_half_float_vertex (GL/glext.h:5209)
GL_ARB_half_float_vertex = 1 # GL/glext.h:5210
# ARB_instanced_arrays (GL/glext.h:5213)
GL_ARB_instanced_arrays = 1 # GL/glext.h:5214
# GL/glext.h:5216
glVertexAttribDivisorARB = _link_function('glVertexAttribDivisorARB', None, [GLuint, GLuint], 'ARB_instanced_arrays')
PFNGLVERTEXATTRIBDIVISORARBPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:5218
# ARB_map_buffer_range (GL/glext.h:5221)
GL_ARB_map_buffer_range = 1 # GL/glext.h:5222
# GL/glext.h:5224
glMapBufferRange = _link_function('glMapBufferRange', None, [GLenum, GLintptr, GLsizeiptr, GLbitfield], 'ARB_map_buffer_range')
# GL/glext.h:5225
glFlushMappedBufferRange = _link_function('glFlushMappedBufferRange', None, [GLenum, GLintptr, GLsizeiptr], 'ARB_map_buffer_range')
PFNGLMAPBUFFERRANGEPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr, GLbitfield) # GL/glext.h:5227
PFNGLFLUSHMAPPEDBUFFERRANGEPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr) # GL/glext.h:5228
# ARB_texture_buffer_object (GL/glext.h:5231)
GL_ARB_texture_buffer_object = 1 # GL/glext.h:5232
# GL/glext.h:5234
glTexBufferARB = _link_function('glTexBufferARB', None, [GLenum, GLenum, GLuint], 'ARB_texture_buffer_object')
PFNGLTEXBUFFERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:5236
# ARB_texture_compression_rgtc (GL/glext.h:5239)
GL_ARB_texture_compression_rgtc = 1 # GL/glext.h:5240
# ARB_texture_rg (GL/glext.h:5243)
GL_ARB_texture_rg = 1 # GL/glext.h:5244
# ARB_vertex_array_object (GL/glext.h:5247)
GL_ARB_vertex_array_object = 1 # GL/glext.h:5248
# GL/glext.h:5250
glBindVertexArray = _link_function('glBindVertexArray', None, [GLuint], 'ARB_vertex_array_object')
# GL/glext.h:5251
glDeleteVertexArrays = _link_function('glDeleteVertexArrays', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_array_object')
# GL/glext.h:5252
glGenVertexArrays = _link_function('glGenVertexArrays', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_array_object')
# GL/glext.h:5253
glIsVertexArray = _link_function('glIsVertexArray', GLboolean, [GLuint], 'ARB_vertex_array_object')
PFNGLBINDVERTEXARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:5255
PFNGLDELETEVERTEXARRAYSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5256
PFNGLGENVERTEXARRAYSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5257
PFNGLISVERTEXARRAYPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5258
# EXT_abgr (GL/glext.h:5261)
GL_EXT_abgr = 1 # GL/glext.h:5262
# EXT_blend_color (GL/glext.h:5265)
GL_EXT_blend_color = 1 # GL/glext.h:5266
# GL/glext.h:5268
glBlendColorEXT = _link_function('glBlendColorEXT', None, [GLclampf, GLclampf, GLclampf, GLclampf], 'EXT_blend_color')
PFNGLBLENDCOLOREXTPROC = CFUNCTYPE(None, GLclampf, GLclampf, GLclampf, GLclampf) # GL/glext.h:5270
# EXT_polygon_offset (GL/glext.h:5273)
GL_EXT_polygon_offset = 1 # GL/glext.h:5274
# GL/glext.h:5276
glPolygonOffsetEXT = _link_function('glPolygonOffsetEXT', None, [GLfloat, GLfloat], 'EXT_polygon_offset')
PFNGLPOLYGONOFFSETEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:5278
# EXT_texture (GL/glext.h:5281)
GL_EXT_texture = 1 # GL/glext.h:5282
# EXT_texture3D (GL/glext.h:5285)
GL_EXT_texture3D = 1 # GL/glext.h:5286
# GL/glext.h:5288
glTexImage3DEXT = _link_function('glTexImage3DEXT', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_texture3D')
# GL/glext.h:5289
glTexSubImage3DEXT = _link_function('glTexSubImage3DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_texture3D')
PFNGLTEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5291
PFNGLTEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5292
# SGIS_texture_filter4 (GL/glext.h:5295)
GL_SGIS_texture_filter4 = 1 # GL/glext.h:5296
# GL/glext.h:5298
glGetTexFilterFuncSGIS = _link_function('glGetTexFilterFuncSGIS', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIS_texture_filter4')
# GL/glext.h:5299
glTexFilterFuncSGIS = _link_function('glTexFilterFuncSGIS', None, [GLenum, GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_texture_filter4')
PFNGLGETTEXFILTERFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5301
PFNGLTEXFILTERFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:5302
# EXT_subtexture (GL/glext.h:5305)
GL_EXT_subtexture = 1 # GL/glext.h:5306
# GL/glext.h:5308
glTexSubImage1DEXT = _link_function('glTexSubImage1DEXT', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_subtexture')
# GL/glext.h:5309
glTexSubImage2DEXT = _link_function('glTexSubImage2DEXT', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_subtexture')
PFNGLTEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5311
PFNGLTEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5312
# EXT_copy_texture (GL/glext.h:5315)
GL_EXT_copy_texture = 1 # GL/glext.h:5316
# GL/glext.h:5318
glCopyTexImage1DEXT = _link_function('glCopyTexImage1DEXT', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_copy_texture')
# GL/glext.h:5319
glCopyTexImage2DEXT = _link_function('glCopyTexImage2DEXT', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_copy_texture')
# GL/glext.h:5320
glCopyTexSubImage1DEXT = _link_function('glCopyTexSubImage1DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_copy_texture')
# GL/glext.h:5321
glCopyTexSubImage2DEXT = _link_function('glCopyTexSubImage2DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_copy_texture')
# GL/glext.h:5322
glCopyTexSubImage3DEXT = _link_function('glCopyTexSubImage3DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_copy_texture')
PFNGLCOPYTEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:5324
PFNGLCOPYTEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:5325
PFNGLCOPYTEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:5326
PFNGLCOPYTEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:5327
PFNGLCOPYTEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:5328
# EXT_histogram (GL/glext.h:5331)
GL_EXT_histogram = 1 # GL/glext.h:5332
# GL/glext.h:5334
glGetHistogramEXT = _link_function('glGetHistogramEXT', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'EXT_histogram')
# GL/glext.h:5335
glGetHistogramParameterfvEXT = _link_function('glGetHistogramParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_histogram')
# GL/glext.h:5336
glGetHistogramParameterivEXT = _link_function('glGetHistogramParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_histogram')
# GL/glext.h:5337
glGetMinmaxEXT = _link_function('glGetMinmaxEXT', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'EXT_histogram')
# GL/glext.h:5338
glGetMinmaxParameterfvEXT = _link_function('glGetMinmaxParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_histogram')
# GL/glext.h:5339
glGetMinmaxParameterivEXT = _link_function('glGetMinmaxParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_histogram')
# GL/glext.h:5340
glHistogramEXT = _link_function('glHistogramEXT', None, [GLenum, GLsizei, GLenum, GLboolean], 'EXT_histogram')
# GL/glext.h:5341
glMinmaxEXT = _link_function('glMinmaxEXT', None, [GLenum, GLenum, GLboolean], 'EXT_histogram')
# GL/glext.h:5342
glResetHistogramEXT = _link_function('glResetHistogramEXT', None, [GLenum], 'EXT_histogram')
# GL/glext.h:5343
glResetMinmaxEXT = _link_function('glResetMinmaxEXT', None, [GLenum], 'EXT_histogram')
PFNGLGETHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5345
PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5346
PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5347
PFNGLGETMINMAXEXTPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5348
PFNGLGETMINMAXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5349
PFNGLGETMINMAXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5350
PFNGLHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLboolean) # GL/glext.h:5351
PFNGLMINMAXEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLboolean) # GL/glext.h:5352
PFNGLRESETHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5353
PFNGLRESETMINMAXEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5354
# EXT_convolution (GL/glext.h:5357)
GL_EXT_convolution = 1 # GL/glext.h:5358
# GL/glext.h:5360
glConvolutionFilter1DEXT = _link_function('glConvolutionFilter1DEXT', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:5361
glConvolutionFilter2DEXT = _link_function('glConvolutionFilter2DEXT', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:5362
glConvolutionParameterfEXT = _link_function('glConvolutionParameterfEXT', None, [GLenum, GLenum, GLfloat], 'EXT_convolution')
# GL/glext.h:5363
glConvolutionParameterfvEXT = _link_function('glConvolutionParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_convolution')
# GL/glext.h:5364
glConvolutionParameteriEXT = _link_function('glConvolutionParameteriEXT', None, [GLenum, GLenum, GLint], 'EXT_convolution')
# GL/glext.h:5365
glConvolutionParameterivEXT = _link_function('glConvolutionParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_convolution')
# GL/glext.h:5366
glCopyConvolutionFilter1DEXT = _link_function('glCopyConvolutionFilter1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'EXT_convolution')
# GL/glext.h:5367
glCopyConvolutionFilter2DEXT = _link_function('glCopyConvolutionFilter2DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLsizei], 'EXT_convolution')
# GL/glext.h:5368
glGetConvolutionFilterEXT = _link_function('glGetConvolutionFilterEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:5369
glGetConvolutionParameterfvEXT = _link_function('glGetConvolutionParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_convolution')
# GL/glext.h:5370
glGetConvolutionParameterivEXT = _link_function('glGetConvolutionParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_convolution')
# GL/glext.h:5371
glGetSeparableFilterEXT = _link_function('glGetSeparableFilterEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:5372
glSeparableFilter2DEXT = _link_function('glSeparableFilter2DEXT', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)], 'EXT_convolution')
PFNGLCONVOLUTIONFILTER1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5374
PFNGLCONVOLUTIONFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5375
PFNGLCONVOLUTIONPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:5376
PFNGLCONVOLUTIONPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5377
PFNGLCONVOLUTIONPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:5378
PFNGLCONVOLUTIONPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5379
PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:5380
PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:5381
PFNGLGETCONVOLUTIONFILTEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5382
PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5383
PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5384
PFNGLGETSEPARABLEFILTEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:5385
PFNGLSEPARABLEFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:5386
# EXT_color_matrix (GL/glext.h:5389)
GL_EXT_color_matrix = 1 # GL/glext.h:5390
# SGI_color_table (GL/glext.h:5393)
GL_SGI_color_table = 1 # GL/glext.h:5394
# GL/glext.h:5396
glColorTableSGI = _link_function('glColorTableSGI', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'SGI_color_table')
# GL/glext.h:5397
glColorTableParameterfvSGI = _link_function('glColorTableParameterfvSGI', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGI_color_table')
# GL/glext.h:5398
glColorTableParameterivSGI = _link_function('glColorTableParameterivSGI', None, [GLenum, GLenum, POINTER(GLint)], 'SGI_color_table')
# GL/glext.h:5399
glCopyColorTableSGI = _link_function('glCopyColorTableSGI', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'SGI_color_table')
# GL/glext.h:5400
glGetColorTableSGI = _link_function('glGetColorTableSGI', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'SGI_color_table')
# GL/glext.h:5401
glGetColorTableParameterfvSGI = _link_function('glGetColorTableParameterfvSGI', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGI_color_table')
# GL/glext.h:5402
glGetColorTableParameterivSGI = _link_function('glGetColorTableParameterivSGI', None, [GLenum, GLenum, POINTER(GLint)], 'SGI_color_table')
PFNGLCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5404
PFNGLCOLORTABLEPARAMETERFVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5405
PFNGLCOLORTABLEPARAMETERIVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5406
PFNGLCOPYCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:5407
PFNGLGETCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5408
PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5409
PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5410
# SGIX_pixel_texture (GL/glext.h:5413)
GL_SGIX_pixel_texture = 1 # GL/glext.h:5414
# GL/glext.h:5416
glPixelTexGenSGIX = _link_function('glPixelTexGenSGIX', None, [GLenum], 'SGIX_pixel_texture')
PFNGLPIXELTEXGENSGIXPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5418
# SGIS_pixel_texture (GL/glext.h:5421)
GL_SGIS_pixel_texture = 1 # GL/glext.h:5422
# GL/glext.h:5424
glPixelTexGenParameteriSGIS = _link_function('glPixelTexGenParameteriSGIS', None, [GLenum, GLint], 'SGIS_pixel_texture')
# GL/glext.h:5425
glPixelTexGenParameterivSGIS = _link_function('glPixelTexGenParameterivSGIS', None, [GLenum, POINTER(GLint)], 'SGIS_pixel_texture')
# GL/glext.h:5426
glPixelTexGenParameterfSGIS = _link_function('glPixelTexGenParameterfSGIS', None, [GLenum, GLfloat], 'SGIS_pixel_texture')
# GL/glext.h:5427
glPixelTexGenParameterfvSGIS = _link_function('glPixelTexGenParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_pixel_texture')
# GL/glext.h:5428
glGetPixelTexGenParameterivSGIS = _link_function('glGetPixelTexGenParameterivSGIS', None, [GLenum, POINTER(GLint)], 'SGIS_pixel_texture')
# GL/glext.h:5429
glGetPixelTexGenParameterfvSGIS = _link_function('glGetPixelTexGenParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_pixel_texture')
PFNGLPIXELTEXGENPARAMETERISGISPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5431
PFNGLPIXELTEXGENPARAMETERIVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5432
PFNGLPIXELTEXGENPARAMETERFSGISPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5433
PFNGLPIXELTEXGENPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5434
PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5435
PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5436
# SGIS_texture4D (GL/glext.h:5439)
GL_SGIS_texture4D = 1 # GL/glext.h:5440
# GL/glext.h:5442
glTexImage4DSGIS = _link_function('glTexImage4DSGIS', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'SGIS_texture4D')
# GL/glext.h:5443
glTexSubImage4DSGIS = _link_function('glTexSubImage4DSGIS', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'SGIS_texture4D')
PFNGLTEXIMAGE4DSGISPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5445
PFNGLTEXSUBIMAGE4DSGISPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5446
# SGI_texture_color_table (GL/glext.h:5449)
GL_SGI_texture_color_table = 1 # GL/glext.h:5450
# EXT_cmyka (GL/glext.h:5453)
GL_EXT_cmyka = 1 # GL/glext.h:5454
# EXT_texture_object (GL/glext.h:5457)
GL_EXT_texture_object = 1 # GL/glext.h:5458
# GL/glext.h:5460
glAreTexturesResidentEXT = _link_function('glAreTexturesResidentEXT', GLboolean, [GLsizei, POINTER(GLuint), POINTER(GLboolean)], 'EXT_texture_object')
# GL/glext.h:5461
glBindTextureEXT = _link_function('glBindTextureEXT', None, [GLenum, GLuint], 'EXT_texture_object')
# GL/glext.h:5462
glDeleteTexturesEXT = _link_function('glDeleteTexturesEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_texture_object')
# GL/glext.h:5463
glGenTexturesEXT = _link_function('glGenTexturesEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_texture_object')
# GL/glext.h:5464
glIsTextureEXT = _link_function('glIsTextureEXT', GLboolean, [GLuint], 'EXT_texture_object')
# GL/glext.h:5465
glPrioritizeTexturesEXT = _link_function('glPrioritizeTexturesEXT', None, [GLsizei, POINTER(GLuint), POINTER(GLclampf)], 'EXT_texture_object')
PFNGLARETEXTURESRESIDENTEXTPROC = CFUNCTYPE(GLboolean, GLsizei, POINTER(GLuint), POINTER(GLboolean)) # GL/glext.h:5467
PFNGLBINDTEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:5468
PFNGLDELETETEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5469
PFNGLGENTEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5470
PFNGLISTEXTUREEXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5471
PFNGLPRIORITIZETEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint), POINTER(GLclampf)) # GL/glext.h:5472
# SGIS_detail_texture (GL/glext.h:5475)
GL_SGIS_detail_texture = 1 # GL/glext.h:5476
# GL/glext.h:5478
glDetailTexFuncSGIS = _link_function('glDetailTexFuncSGIS', None, [GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_detail_texture')
# GL/glext.h:5479
glGetDetailTexFuncSGIS = _link_function('glGetDetailTexFuncSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_detail_texture')
PFNGLDETAILTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:5481
PFNGLGETDETAILTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5482
# SGIS_sharpen_texture (GL/glext.h:5485)
GL_SGIS_sharpen_texture = 1 # GL/glext.h:5486
# GL/glext.h:5488
glSharpenTexFuncSGIS = _link_function('glSharpenTexFuncSGIS', None, [GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_sharpen_texture')
# GL/glext.h:5489
glGetSharpenTexFuncSGIS = _link_function('glGetSharpenTexFuncSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_sharpen_texture')
PFNGLSHARPENTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:5491
PFNGLGETSHARPENTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5492
# EXT_packed_pixels (GL/glext.h:5495)
GL_EXT_packed_pixels = 1 # GL/glext.h:5496
# SGIS_texture_lod (GL/glext.h:5499)
GL_SGIS_texture_lod = 1 # GL/glext.h:5500
# SGIS_multisample (GL/glext.h:5503)
GL_SGIS_multisample = 1 # GL/glext.h:5504
# GL/glext.h:5506
glSampleMaskSGIS = _link_function('glSampleMaskSGIS', None, [GLclampf, GLboolean], 'SGIS_multisample')
# GL/glext.h:5507
glSamplePatternSGIS = _link_function('glSamplePatternSGIS', None, [GLenum], 'SGIS_multisample')
PFNGLSAMPLEMASKSGISPROC = CFUNCTYPE(None, GLclampf, GLboolean) # GL/glext.h:5509
PFNGLSAMPLEPATTERNSGISPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5510
# EXT_rescale_normal (GL/glext.h:5513)
GL_EXT_rescale_normal = 1 # GL/glext.h:5514
# EXT_vertex_array (GL/glext.h:5517)
GL_EXT_vertex_array = 1 # GL/glext.h:5518
# GL/glext.h:5520
glArrayElementEXT = _link_function('glArrayElementEXT', None, [GLint], 'EXT_vertex_array')
# GL/glext.h:5521
glColorPointerEXT = _link_function('glColorPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:5522
glDrawArraysEXT = _link_function('glDrawArraysEXT', None, [GLenum, GLint, GLsizei], 'EXT_vertex_array')
# GL/glext.h:5523
glEdgeFlagPointerEXT = _link_function('glEdgeFlagPointerEXT', None, [GLsizei, GLsizei, POINTER(GLboolean)], 'EXT_vertex_array')
# GL/glext.h:5524
glGetPointervEXT = _link_function('glGetPointervEXT', None, [GLenum, POINTER(POINTER(GLvoid))], 'EXT_vertex_array')
# GL/glext.h:5525
glIndexPointerEXT = _link_function('glIndexPointerEXT', None, [GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:5526
glNormalPointerEXT = _link_function('glNormalPointerEXT', None, [GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:5527
glTexCoordPointerEXT = _link_function('glTexCoordPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:5528
glVertexPointerEXT = _link_function('glVertexPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
PFNGLARRAYELEMENTEXTPROC = CFUNCTYPE(None, GLint) # GL/glext.h:5530
PFNGLCOLORPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:5531
PFNGLDRAWARRAYSEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei) # GL/glext.h:5532
PFNGLEDGEFLAGPOINTEREXTPROC = CFUNCTYPE(None, GLsizei, GLsizei, POINTER(GLboolean)) # GL/glext.h:5533
PFNGLGETPOINTERVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5534
PFNGLINDEXPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:5535
PFNGLNORMALPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:5536
PFNGLTEXCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:5537
PFNGLVERTEXPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:5538
# EXT_misc_attribute (GL/glext.h:5541)
GL_EXT_misc_attribute = 1 # GL/glext.h:5542
# SGIS_generate_mipmap (GL/glext.h:5545)
GL_SGIS_generate_mipmap = 1 # GL/glext.h:5546
# SGIX_clipmap (GL/glext.h:5549)
GL_SGIX_clipmap = 1 # GL/glext.h:5550
# SGIX_shadow (GL/glext.h:5553)
GL_SGIX_shadow = 1 # GL/glext.h:5554
# SGIS_texture_edge_clamp (GL/glext.h:5557)
GL_SGIS_texture_edge_clamp = 1 # GL/glext.h:5558
# SGIS_texture_border_clamp (GL/glext.h:5561)
GL_SGIS_texture_border_clamp = 1 # GL/glext.h:5562
# EXT_blend_minmax (GL/glext.h:5565)
GL_EXT_blend_minmax = 1 # GL/glext.h:5566
# GL/glext.h:5568
glBlendEquationEXT = _link_function('glBlendEquationEXT', None, [GLenum], 'EXT_blend_minmax')
PFNGLBLENDEQUATIONEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5570
# EXT_blend_subtract (GL/glext.h:5573)
GL_EXT_blend_subtract = 1 # GL/glext.h:5574
# EXT_blend_logic_op (GL/glext.h:5577)
GL_EXT_blend_logic_op = 1 # GL/glext.h:5578
# SGIX_interlace (GL/glext.h:5581)
GL_SGIX_interlace = 1 # GL/glext.h:5582
# SGIX_pixel_tiles (GL/glext.h:5585)
GL_SGIX_pixel_tiles = 1 # GL/glext.h:5586
# SGIX_texture_select (GL/glext.h:5589)
GL_SGIX_texture_select = 1 # GL/glext.h:5590
# SGIX_sprite (GL/glext.h:5593)
GL_SGIX_sprite = 1 # GL/glext.h:5594
# GL/glext.h:5596
glSpriteParameterfSGIX = _link_function('glSpriteParameterfSGIX', None, [GLenum, GLfloat], 'SGIX_sprite')
# GL/glext.h:5597
glSpriteParameterfvSGIX = _link_function('glSpriteParameterfvSGIX', None, [GLenum, POINTER(GLfloat)], 'SGIX_sprite')
# GL/glext.h:5598
glSpriteParameteriSGIX = _link_function('glSpriteParameteriSGIX', None, [GLenum, GLint], 'SGIX_sprite')
# GL/glext.h:5599
glSpriteParameterivSGIX = _link_function('glSpriteParameterivSGIX', None, [GLenum, POINTER(GLint)], 'SGIX_sprite')
PFNGLSPRITEPARAMETERFSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5601
PFNGLSPRITEPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5602
PFNGLSPRITEPARAMETERISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5603
PFNGLSPRITEPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5604
# SGIX_texture_multi_buffer (GL/glext.h:5607)
GL_SGIX_texture_multi_buffer = 1 # GL/glext.h:5608
# EXT_point_parameters (GL/glext.h:5611)
GL_EXT_point_parameters = 1 # GL/glext.h:5612
# GL/glext.h:5614
glPointParameterfEXT = _link_function('glPointParameterfEXT', None, [GLenum, GLfloat], 'EXT_point_parameters')
# GL/glext.h:5615
glPointParameterfvEXT = _link_function('glPointParameterfvEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_point_parameters')
PFNGLPOINTPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5617
PFNGLPOINTPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5618
# SGIS_point_parameters (GL/glext.h:5621)
GL_SGIS_point_parameters = 1 # GL/glext.h:5622
# GL/glext.h:5624
glPointParameterfSGIS = _link_function('glPointParameterfSGIS', None, [GLenum, GLfloat], 'SGIS_point_parameters')
# GL/glext.h:5625
glPointParameterfvSGIS = _link_function('glPointParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_point_parameters')
PFNGLPOINTPARAMETERFSGISPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5627
PFNGLPOINTPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5628
# SGIX_instruments (GL/glext.h:5631)
GL_SGIX_instruments = 1 # GL/glext.h:5632
# GL/glext.h:5634
glGetInstrumentsSGIX = _link_function('glGetInstrumentsSGIX', GLint, [], 'SGIX_instruments')
# GL/glext.h:5635
glInstrumentsBufferSGIX = _link_function('glInstrumentsBufferSGIX', None, [GLsizei, POINTER(GLint)], 'SGIX_instruments')
# GL/glext.h:5636
glPollInstrumentsSGIX = _link_function('glPollInstrumentsSGIX', GLint, [POINTER(GLint)], 'SGIX_instruments')
# GL/glext.h:5637
glReadInstrumentsSGIX = _link_function('glReadInstrumentsSGIX', None, [GLint], 'SGIX_instruments')
# GL/glext.h:5638
glStartInstrumentsSGIX = _link_function('glStartInstrumentsSGIX', None, [], 'SGIX_instruments')
# GL/glext.h:5639
glStopInstrumentsSGIX = _link_function('glStopInstrumentsSGIX', None, [GLint], 'SGIX_instruments')
PFNGLGETINSTRUMENTSSGIXPROC = CFUNCTYPE(GLint) # GL/glext.h:5641
PFNGLINSTRUMENTSBUFFERSGIXPROC = CFUNCTYPE(None, GLsizei, POINTER(GLint)) # GL/glext.h:5642
PFNGLPOLLINSTRUMENTSSGIXPROC = CFUNCTYPE(GLint, POINTER(GLint)) # GL/glext.h:5643
PFNGLREADINSTRUMENTSSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:5644
PFNGLSTARTINSTRUMENTSSGIXPROC = CFUNCTYPE(None) # GL/glext.h:5645
PFNGLSTOPINSTRUMENTSSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:5646
# SGIX_texture_scale_bias (GL/glext.h:5649)
GL_SGIX_texture_scale_bias = 1 # GL/glext.h:5650
# SGIX_framezoom (GL/glext.h:5653)
GL_SGIX_framezoom = 1 # GL/glext.h:5654
# GL/glext.h:5656
glFrameZoomSGIX = _link_function('glFrameZoomSGIX', None, [GLint], 'SGIX_framezoom')
PFNGLFRAMEZOOMSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:5658
# SGIX_tag_sample_buffer (GL/glext.h:5661)
GL_SGIX_tag_sample_buffer = 1 # GL/glext.h:5662
# GL/glext.h:5664
glTagSampleBufferSGIX = _link_function('glTagSampleBufferSGIX', None, [], 'SGIX_tag_sample_buffer')
PFNGLTAGSAMPLEBUFFERSGIXPROC = CFUNCTYPE(None) # GL/glext.h:5666
# SGIX_polynomial_ffd (GL/glext.h:5669)
GL_SGIX_polynomial_ffd = 1 # GL/glext.h:5670
# GL/glext.h:5672
glDeformationMap3dSGIX = _link_function('glDeformationMap3dSGIX', None, [GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], 'SGIX_polynomial_ffd')
# GL/glext.h:5673
glDeformationMap3fSGIX = _link_function('glDeformationMap3fSGIX', None, [GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], 'SGIX_polynomial_ffd')
# GL/glext.h:5674
glDeformSGIX = _link_function('glDeformSGIX', None, [GLbitfield], 'SGIX_polynomial_ffd')
# GL/glext.h:5675
glLoadIdentityDeformationMapSGIX = _link_function('glLoadIdentityDeformationMapSGIX', None, [GLbitfield], 'SGIX_polynomial_ffd')
PFNGLDEFORMATIONMAP3DSGIXPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)) # GL/glext.h:5677
PFNGLDEFORMATIONMAP3FSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)) # GL/glext.h:5678
PFNGLDEFORMSGIXPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:5679
PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:5680
# SGIX_reference_plane (GL/glext.h:5683)
GL_SGIX_reference_plane = 1 # GL/glext.h:5684
# GL/glext.h:5686
glReferencePlaneSGIX = _link_function('glReferencePlaneSGIX', None, [POINTER(GLdouble)], 'SGIX_reference_plane')
PFNGLREFERENCEPLANESGIXPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5688
# SGIX_flush_raster (GL/glext.h:5691)
GL_SGIX_flush_raster = 1 # GL/glext.h:5692
# GL/glext.h:5694
glFlushRasterSGIX = _link_function('glFlushRasterSGIX', None, [], 'SGIX_flush_raster')
PFNGLFLUSHRASTERSGIXPROC = CFUNCTYPE(None) # GL/glext.h:5696
# SGIX_depth_texture (GL/glext.h:5699)
GL_SGIX_depth_texture = 1 # GL/glext.h:5700
# SGIS_fog_function (GL/glext.h:5703)
GL_SGIS_fog_function = 1 # GL/glext.h:5704
# GL/glext.h:5706
glFogFuncSGIS = _link_function('glFogFuncSGIS', None, [GLsizei, POINTER(GLfloat)], 'SGIS_fog_function')
# GL/glext.h:5707
glGetFogFuncSGIS = _link_function('glGetFogFuncSGIS', None, [POINTER(GLfloat)], 'SGIS_fog_function')
PFNGLFOGFUNCSGISPROC = CFUNCTYPE(None, GLsizei, POINTER(GLfloat)) # GL/glext.h:5709
PFNGLGETFOGFUNCSGISPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5710
# SGIX_fog_offset (GL/glext.h:5713)
GL_SGIX_fog_offset = 1 # GL/glext.h:5714
# HP_image_transform (GL/glext.h:5717)
GL_HP_image_transform = 1 # GL/glext.h:5718
# GL/glext.h:5720
glImageTransformParameteriHP = _link_function('glImageTransformParameteriHP', None, [GLenum, GLenum, GLint], 'HP_image_transform')
# GL/glext.h:5721
glImageTransformParameterfHP = _link_function('glImageTransformParameterfHP', None, [GLenum, GLenum, GLfloat], 'HP_image_transform')
# GL/glext.h:5722
glImageTransformParameterivHP = _link_function('glImageTransformParameterivHP', None, [GLenum, GLenum, POINTER(GLint)], 'HP_image_transform')
# GL/glext.h:5723
glImageTransformParameterfvHP = _link_function('glImageTransformParameterfvHP', None, [GLenum, GLenum, POINTER(GLfloat)], 'HP_image_transform')
# GL/glext.h:5724
glGetImageTransformParameterivHP = _link_function('glGetImageTransformParameterivHP', None, [GLenum, GLenum, POINTER(GLint)], 'HP_image_transform')
# GL/glext.h:5725
glGetImageTransformParameterfvHP = _link_function('glGetImageTransformParameterfvHP', None, [GLenum, GLenum, POINTER(GLfloat)], 'HP_image_transform')
PFNGLIMAGETRANSFORMPARAMETERIHPPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:5727
PFNGLIMAGETRANSFORMPARAMETERFHPPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:5728
PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5729
PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5730
PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5731
PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5732
# HP_convolution_border_modes (GL/glext.h:5735)
GL_HP_convolution_border_modes = 1 # GL/glext.h:5736
# SGIX_texture_add_env (GL/glext.h:5739)
GL_SGIX_texture_add_env = 1 # GL/glext.h:5740
# EXT_color_subtable (GL/glext.h:5743)
GL_EXT_color_subtable = 1 # GL/glext.h:5744
# GL/glext.h:5746
glColorSubTableEXT = _link_function('glColorSubTableEXT', None, [GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_color_subtable')
# GL/glext.h:5747
glCopyColorSubTableEXT = _link_function('glCopyColorSubTableEXT', None, [GLenum, GLsizei, GLint, GLint, GLsizei], 'EXT_color_subtable')
PFNGLCOLORSUBTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5749
PFNGLCOPYCOLORSUBTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLint, GLint, GLsizei) # GL/glext.h:5750
# PGI_vertex_hints (GL/glext.h:5753)
GL_PGI_vertex_hints = 1 # GL/glext.h:5754
# PGI_misc_hints (GL/glext.h:5757)
GL_PGI_misc_hints = 1 # GL/glext.h:5758
# GL/glext.h:5760
glHintPGI = _link_function('glHintPGI', None, [GLenum, GLint], 'PGI_misc_hints')
PFNGLHINTPGIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5762
# EXT_paletted_texture (GL/glext.h:5765)
GL_EXT_paletted_texture = 1 # GL/glext.h:5766
# GL/glext.h:5768
glColorTableEXT = _link_function('glColorTableEXT', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_paletted_texture')
# GL/glext.h:5769
glGetColorTableEXT = _link_function('glGetColorTableEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'EXT_paletted_texture')
# GL/glext.h:5770
glGetColorTableParameterivEXT = _link_function('glGetColorTableParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_paletted_texture')
# GL/glext.h:5771
glGetColorTableParameterfvEXT = _link_function('glGetColorTableParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_paletted_texture')
PFNGLCOLORTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5773
PFNGLGETCOLORTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5774
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5775
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5776
# EXT_clip_volume_hint (GL/glext.h:5779)
GL_EXT_clip_volume_hint = 1 # GL/glext.h:5780
# SGIX_list_priority (GL/glext.h:5783)
GL_SGIX_list_priority = 1 # GL/glext.h:5784
# GL/glext.h:5786
glGetListParameterfvSGIX = _link_function('glGetListParameterfvSGIX', None, [GLuint, GLenum, POINTER(GLfloat)], 'SGIX_list_priority')
# GL/glext.h:5787
glGetListParameterivSGIX = _link_function('glGetListParameterivSGIX', None, [GLuint, GLenum, POINTER(GLint)], 'SGIX_list_priority')
# GL/glext.h:5788
glListParameterfSGIX = _link_function('glListParameterfSGIX', None, [GLuint, GLenum, GLfloat], 'SGIX_list_priority')
# GL/glext.h:5789
glListParameterfvSGIX = _link_function('glListParameterfvSGIX', None, [GLuint, GLenum, POINTER(GLfloat)], 'SGIX_list_priority')
# GL/glext.h:5790
glListParameteriSGIX = _link_function('glListParameteriSGIX', None, [GLuint, GLenum, GLint], 'SGIX_list_priority')
# GL/glext.h:5791
glListParameterivSGIX = _link_function('glListParameterivSGIX', None, [GLuint, GLenum, POINTER(GLint)], 'SGIX_list_priority')
PFNGLGETLISTPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:5793
PFNGLGETLISTPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:5794
PFNGLLISTPARAMETERFSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, GLfloat) # GL/glext.h:5795
PFNGLLISTPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:5796
PFNGLLISTPARAMETERISGIXPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:5797
PFNGLLISTPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:5798
# SGIX_ir_instrument1 (GL/glext.h:5801)
GL_SGIX_ir_instrument1 = 1 # GL/glext.h:5802
# SGIX_calligraphic_fragment (GL/glext.h:5805)
GL_SGIX_calligraphic_fragment = 1 # GL/glext.h:5806
# SGIX_texture_lod_bias (GL/glext.h:5809)
GL_SGIX_texture_lod_bias = 1 # GL/glext.h:5810
# SGIX_shadow_ambient (GL/glext.h:5813)
GL_SGIX_shadow_ambient = 1 # GL/glext.h:5814
# EXT_index_texture (GL/glext.h:5817)
GL_EXT_index_texture = 1 # GL/glext.h:5818
# EXT_index_material (GL/glext.h:5821)
GL_EXT_index_material = 1 # GL/glext.h:5822
# GL/glext.h:5824
glIndexMaterialEXT = _link_function('glIndexMaterialEXT', None, [GLenum, GLenum], 'EXT_index_material')
PFNGLINDEXMATERIALEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:5826
# EXT_index_func (GL/glext.h:5829)
GL_EXT_index_func = 1 # GL/glext.h:5830
# GL/glext.h:5832
glIndexFuncEXT = _link_function('glIndexFuncEXT', None, [GLenum, GLclampf], 'EXT_index_func')
PFNGLINDEXFUNCEXTPROC = CFUNCTYPE(None, GLenum, GLclampf) # GL/glext.h:5834
# EXT_index_array_formats (GL/glext.h:5837)
GL_EXT_index_array_formats = 1 # GL/glext.h:5838
# EXT_compiled_vertex_array (GL/glext.h:5841)
GL_EXT_compiled_vertex_array = 1 # GL/glext.h:5842
# GL/glext.h:5844
glLockArraysEXT = _link_function('glLockArraysEXT', None, [GLint, GLsizei], 'EXT_compiled_vertex_array')
# GL/glext.h:5845
glUnlockArraysEXT = _link_function('glUnlockArraysEXT', None, [], 'EXT_compiled_vertex_array')
PFNGLLOCKARRAYSEXTPROC = CFUNCTYPE(None, GLint, GLsizei) # GL/glext.h:5847
PFNGLUNLOCKARRAYSEXTPROC = CFUNCTYPE(None) # GL/glext.h:5848
# EXT_cull_vertex (GL/glext.h:5851)
GL_EXT_cull_vertex = 1 # GL/glext.h:5852
# GL/glext.h:5854
glCullParameterdvEXT = _link_function('glCullParameterdvEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_cull_vertex')
# GL/glext.h:5855
glCullParameterfvEXT = _link_function('glCullParameterfvEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_cull_vertex')
PFNGLCULLPARAMETERDVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:5857
PFNGLCULLPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5858
# SGIX_ycrcb (GL/glext.h:5861)
GL_SGIX_ycrcb = 1 # GL/glext.h:5862
# SGIX_fragment_lighting (GL/glext.h:5865)
GL_SGIX_fragment_lighting = 1 # GL/glext.h:5866
# GL/glext.h:5868
glFragmentColorMaterialSGIX = _link_function('glFragmentColorMaterialSGIX', None, [GLenum, GLenum], 'SGIX_fragment_lighting')
# GL/glext.h:5869
glFragmentLightfSGIX = _link_function('glFragmentLightfSGIX', None, [GLenum, GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:5870
glFragmentLightfvSGIX = _link_function('glFragmentLightfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:5871
glFragmentLightiSGIX = _link_function('glFragmentLightiSGIX', None, [GLenum, GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:5872
glFragmentLightivSGIX = _link_function('glFragmentLightivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:5873
glFragmentLightModelfSGIX = _link_function('glFragmentLightModelfSGIX', None, [GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:5874
glFragmentLightModelfvSGIX = _link_function('glFragmentLightModelfvSGIX', None, [GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:5875
glFragmentLightModeliSGIX = _link_function('glFragmentLightModeliSGIX', None, [GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:5876
glFragmentLightModelivSGIX = _link_function('glFragmentLightModelivSGIX', None, [GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:5877
glFragmentMaterialfSGIX = _link_function('glFragmentMaterialfSGIX', None, [GLenum, GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:5878
glFragmentMaterialfvSGIX = _link_function('glFragmentMaterialfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:5879
glFragmentMaterialiSGIX = _link_function('glFragmentMaterialiSGIX', None, [GLenum, GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:5880
glFragmentMaterialivSGIX = _link_function('glFragmentMaterialivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:5881
glGetFragmentLightfvSGIX = _link_function('glGetFragmentLightfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:5882
glGetFragmentLightivSGIX = _link_function('glGetFragmentLightivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:5883
glGetFragmentMaterialfvSGIX = _link_function('glGetFragmentMaterialfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:5884
glGetFragmentMaterialivSGIX = _link_function('glGetFragmentMaterialivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:5885
glLightEnviSGIX = _link_function('glLightEnviSGIX', None, [GLenum, GLint], 'SGIX_fragment_lighting')
PFNGLFRAGMENTCOLORMATERIALSGIXPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:5887
PFNGLFRAGMENTLIGHTFSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:5888
PFNGLFRAGMENTLIGHTFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5889
PFNGLFRAGMENTLIGHTISGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:5890
PFNGLFRAGMENTLIGHTIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5891
PFNGLFRAGMENTLIGHTMODELFSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5892
PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5893
PFNGLFRAGMENTLIGHTMODELISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5894
PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5895
PFNGLFRAGMENTMATERIALFSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:5896
PFNGLFRAGMENTMATERIALFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5897
PFNGLFRAGMENTMATERIALISGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:5898
PFNGLFRAGMENTMATERIALIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5899
PFNGLGETFRAGMENTLIGHTFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5900
PFNGLGETFRAGMENTLIGHTIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5901
PFNGLGETFRAGMENTMATERIALFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5902
PFNGLGETFRAGMENTMATERIALIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5903
PFNGLLIGHTENVISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5904
# IBM_rasterpos_clip (GL/glext.h:5907)
GL_IBM_rasterpos_clip = 1 # GL/glext.h:5908
# HP_texture_lighting (GL/glext.h:5911)
GL_HP_texture_lighting = 1 # GL/glext.h:5912
# EXT_draw_range_elements (GL/glext.h:5915)
GL_EXT_draw_range_elements = 1 # GL/glext.h:5916
# GL/glext.h:5918
glDrawRangeElementsEXT = _link_function('glDrawRangeElementsEXT', None, [GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)], 'EXT_draw_range_elements')
PFNGLDRAWRANGEELEMENTSEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:5920
# WIN_phong_shading (GL/glext.h:5923)
GL_WIN_phong_shading = 1 # GL/glext.h:5924
# WIN_specular_fog (GL/glext.h:5927)
GL_WIN_specular_fog = 1 # GL/glext.h:5928
# EXT_light_texture (GL/glext.h:5931)
GL_EXT_light_texture = 1 # GL/glext.h:5932
# GL/glext.h:5934
glApplyTextureEXT = _link_function('glApplyTextureEXT', None, [GLenum], 'EXT_light_texture')
# GL/glext.h:5935
glTextureLightEXT = _link_function('glTextureLightEXT', None, [GLenum], 'EXT_light_texture')
# GL/glext.h:5936
glTextureMaterialEXT = _link_function('glTextureMaterialEXT', None, [GLenum, GLenum], 'EXT_light_texture')
PFNGLAPPLYTEXTUREEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5938
PFNGLTEXTURELIGHTEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5939
PFNGLTEXTUREMATERIALEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:5940
# SGIX_blend_alpha_minmax (GL/glext.h:5943)
GL_SGIX_blend_alpha_minmax = 1 # GL/glext.h:5944
# EXT_bgra (GL/glext.h:5947)
GL_EXT_bgra = 1 # GL/glext.h:5948
# SGIX_async (GL/glext.h:5951)
GL_SGIX_async = 1 # GL/glext.h:5952
# GL/glext.h:5954
glAsyncMarkerSGIX = _link_function('glAsyncMarkerSGIX', None, [GLuint], 'SGIX_async')
# GL/glext.h:5955
glFinishAsyncSGIX = _link_function('glFinishAsyncSGIX', GLint, [POINTER(GLuint)], 'SGIX_async')
# GL/glext.h:5956
glPollAsyncSGIX = _link_function('glPollAsyncSGIX', GLint, [POINTER(GLuint)], 'SGIX_async')
# GL/glext.h:5957
glGenAsyncMarkersSGIX = _link_function('glGenAsyncMarkersSGIX', GLuint, [GLsizei], 'SGIX_async')
# GL/glext.h:5958
glDeleteAsyncMarkersSGIX = _link_function('glDeleteAsyncMarkersSGIX', None, [GLuint, GLsizei], 'SGIX_async')
# GL/glext.h:5959
glIsAsyncMarkerSGIX = _link_function('glIsAsyncMarkerSGIX', GLboolean, [GLuint], 'SGIX_async')
PFNGLASYNCMARKERSGIXPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:5961
PFNGLFINISHASYNCSGIXPROC = CFUNCTYPE(GLint, POINTER(GLuint)) # GL/glext.h:5962
PFNGLPOLLASYNCSGIXPROC = CFUNCTYPE(GLint, POINTER(GLuint)) # GL/glext.h:5963
PFNGLGENASYNCMARKERSSGIXPROC = CFUNCTYPE(GLuint, GLsizei) # GL/glext.h:5964
PFNGLDELETEASYNCMARKERSSGIXPROC = CFUNCTYPE(None, GLuint, GLsizei) # GL/glext.h:5965
PFNGLISASYNCMARKERSGIXPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5966
# SGIX_async_pixel (GL/glext.h:5969)
GL_SGIX_async_pixel = 1 # GL/glext.h:5970
# SGIX_async_histogram (GL/glext.h:5973)
GL_SGIX_async_histogram = 1 # GL/glext.h:5974
# INTEL_parallel_arrays (GL/glext.h:5977)
GL_INTEL_parallel_arrays = 1 # GL/glext.h:5978
# GL/glext.h:5980
glVertexPointervINTEL = _link_function('glVertexPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:5981
glNormalPointervINTEL = _link_function('glNormalPointervINTEL', None, [GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:5982
glColorPointervINTEL = _link_function('glColorPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:5983
glTexCoordPointervINTEL = _link_function('glTexCoordPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
PFNGLVERTEXPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5985
PFNGLNORMALPOINTERVINTELPROC = CFUNCTYPE(None, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5986
PFNGLCOLORPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5987
PFNGLTEXCOORDPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5988
# HP_occlusion_test (GL/glext.h:5991)
GL_HP_occlusion_test = 1 # GL/glext.h:5992
# EXT_pixel_transform (GL/glext.h:5995)
GL_EXT_pixel_transform = 1 # GL/glext.h:5996
# GL/glext.h:5998
glPixelTransformParameteriEXT = _link_function('glPixelTransformParameteriEXT', None, [GLenum, GLenum, GLint], 'EXT_pixel_transform')
# GL/glext.h:5999
glPixelTransformParameterfEXT = _link_function('glPixelTransformParameterfEXT', None, [GLenum, GLenum, GLfloat], 'EXT_pixel_transform')
# GL/glext.h:6000
glPixelTransformParameterivEXT = _link_function('glPixelTransformParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_pixel_transform')
# GL/glext.h:6001
glPixelTransformParameterfvEXT = _link_function('glPixelTransformParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_pixel_transform')
PFNGLPIXELTRANSFORMPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:6003
PFNGLPIXELTRANSFORMPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:6004
PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6005
PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6006
# EXT_pixel_transform_color_table (GL/glext.h:6009)
GL_EXT_pixel_transform_color_table = 1 # GL/glext.h:6010
# EXT_shared_texture_palette (GL/glext.h:6013)
GL_EXT_shared_texture_palette = 1 # GL/glext.h:6014
# EXT_separate_specular_color (GL/glext.h:6017)
GL_EXT_separate_specular_color = 1 # GL/glext.h:6018
# EXT_secondary_color (GL/glext.h:6021)
GL_EXT_secondary_color = 1 # GL/glext.h:6022
# GL/glext.h:6024
glSecondaryColor3bEXT = _link_function('glSecondaryColor3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_secondary_color')
# GL/glext.h:6025
glSecondaryColor3bvEXT = _link_function('glSecondaryColor3bvEXT', None, [POINTER(GLbyte)], 'EXT_secondary_color')
# GL/glext.h:6026
glSecondaryColor3dEXT = _link_function('glSecondaryColor3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_secondary_color')
# GL/glext.h:6027
glSecondaryColor3dvEXT = _link_function('glSecondaryColor3dvEXT', None, [POINTER(GLdouble)], 'EXT_secondary_color')
# GL/glext.h:6028
glSecondaryColor3fEXT = _link_function('glSecondaryColor3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_secondary_color')
# GL/glext.h:6029
glSecondaryColor3fvEXT = _link_function('glSecondaryColor3fvEXT', None, [POINTER(GLfloat)], 'EXT_secondary_color')
# GL/glext.h:6030
glSecondaryColor3iEXT = _link_function('glSecondaryColor3iEXT', None, [GLint, GLint, GLint], 'EXT_secondary_color')
# GL/glext.h:6031
glSecondaryColor3ivEXT = _link_function('glSecondaryColor3ivEXT', None, [POINTER(GLint)], 'EXT_secondary_color')
# GL/glext.h:6032
glSecondaryColor3sEXT = _link_function('glSecondaryColor3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_secondary_color')
# GL/glext.h:6033
glSecondaryColor3svEXT = _link_function('glSecondaryColor3svEXT', None, [POINTER(GLshort)], 'EXT_secondary_color')
# GL/glext.h:6034
glSecondaryColor3ubEXT = _link_function('glSecondaryColor3ubEXT', None, [GLubyte, GLubyte, GLubyte], 'EXT_secondary_color')
# GL/glext.h:6035
glSecondaryColor3ubvEXT = _link_function('glSecondaryColor3ubvEXT', None, [POINTER(GLubyte)], 'EXT_secondary_color')
# GL/glext.h:6036
glSecondaryColor3uiEXT = _link_function('glSecondaryColor3uiEXT', None, [GLuint, GLuint, GLuint], 'EXT_secondary_color')
# GL/glext.h:6037
glSecondaryColor3uivEXT = _link_function('glSecondaryColor3uivEXT', None, [POINTER(GLuint)], 'EXT_secondary_color')
# GL/glext.h:6038
glSecondaryColor3usEXT = _link_function('glSecondaryColor3usEXT', None, [GLushort, GLushort, GLushort], 'EXT_secondary_color')
# GL/glext.h:6039
glSecondaryColor3usvEXT = _link_function('glSecondaryColor3usvEXT', None, [POINTER(GLushort)], 'EXT_secondary_color')
# GL/glext.h:6040
glSecondaryColorPointerEXT = _link_function('glSecondaryColorPointerEXT', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_secondary_color')
PFNGLSECONDARYCOLOR3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:6042
PFNGLSECONDARYCOLOR3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:6043
PFNGLSECONDARYCOLOR3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:6044
PFNGLSECONDARYCOLOR3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6045
PFNGLSECONDARYCOLOR3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:6046
PFNGLSECONDARYCOLOR3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6047
PFNGLSECONDARYCOLOR3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6048
PFNGLSECONDARYCOLOR3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6049
PFNGLSECONDARYCOLOR3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:6050
PFNGLSECONDARYCOLOR3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6051
PFNGLSECONDARYCOLOR3UBEXTPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte) # GL/glext.h:6052
PFNGLSECONDARYCOLOR3UBVEXTPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:6053
PFNGLSECONDARYCOLOR3UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:6054
PFNGLSECONDARYCOLOR3UIVEXTPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:6055
PFNGLSECONDARYCOLOR3USEXTPROC = CFUNCTYPE(None, GLushort, GLushort, GLushort) # GL/glext.h:6056
PFNGLSECONDARYCOLOR3USVEXTPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:6057
PFNGLSECONDARYCOLORPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6058
# EXT_texture_perturb_normal (GL/glext.h:6061)
GL_EXT_texture_perturb_normal = 1 # GL/glext.h:6062
# GL/glext.h:6064
glTextureNormalEXT = _link_function('glTextureNormalEXT', None, [GLenum], 'EXT_texture_perturb_normal')
PFNGLTEXTURENORMALEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:6066
# EXT_multi_draw_arrays (GL/glext.h:6069)
GL_EXT_multi_draw_arrays = 1 # GL/glext.h:6070
# GL/glext.h:6072
glMultiDrawArraysEXT = _link_function('glMultiDrawArraysEXT', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'EXT_multi_draw_arrays')
# GL/glext.h:6073
glMultiDrawElementsEXT = _link_function('glMultiDrawElementsEXT', None, [GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei], 'EXT_multi_draw_arrays')
PFNGLMULTIDRAWARRAYSEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:6075
PFNGLMULTIDRAWELEMENTSEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei) # GL/glext.h:6076
# EXT_fog_coord (GL/glext.h:6079)
GL_EXT_fog_coord = 1 # GL/glext.h:6080
# GL/glext.h:6082
glFogCoordfEXT = _link_function('glFogCoordfEXT', None, [GLfloat], 'EXT_fog_coord')
# GL/glext.h:6083
glFogCoordfvEXT = _link_function('glFogCoordfvEXT', None, [POINTER(GLfloat)], 'EXT_fog_coord')
# GL/glext.h:6084
glFogCoorddEXT = _link_function('glFogCoorddEXT', None, [GLdouble], 'EXT_fog_coord')
# GL/glext.h:6085
glFogCoorddvEXT = _link_function('glFogCoorddvEXT', None, [POINTER(GLdouble)], 'EXT_fog_coord')
# GL/glext.h:6086
glFogCoordPointerEXT = _link_function('glFogCoordPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_fog_coord')
PFNGLFOGCOORDFEXTPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:6088
PFNGLFOGCOORDFVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6089
PFNGLFOGCOORDDEXTPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:6090
PFNGLFOGCOORDDVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6091
PFNGLFOGCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6092
# REND_screen_coordinates (GL/glext.h:6095)
GL_REND_screen_coordinates = 1 # GL/glext.h:6096
# EXT_coordinate_frame (GL/glext.h:6099)
GL_EXT_coordinate_frame = 1 # GL/glext.h:6100
# GL/glext.h:6102
glTangent3bEXT = _link_function('glTangent3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_coordinate_frame')
# GL/glext.h:6103
glTangent3bvEXT = _link_function('glTangent3bvEXT', None, [POINTER(GLbyte)], 'EXT_coordinate_frame')
# GL/glext.h:6104
glTangent3dEXT = _link_function('glTangent3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_coordinate_frame')
# GL/glext.h:6105
glTangent3dvEXT = _link_function('glTangent3dvEXT', None, [POINTER(GLdouble)], 'EXT_coordinate_frame')
# GL/glext.h:6106
glTangent3fEXT = _link_function('glTangent3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_coordinate_frame')
# GL/glext.h:6107
glTangent3fvEXT = _link_function('glTangent3fvEXT', None, [POINTER(GLfloat)], 'EXT_coordinate_frame')
# GL/glext.h:6108
glTangent3iEXT = _link_function('glTangent3iEXT', None, [GLint, GLint, GLint], 'EXT_coordinate_frame')
# GL/glext.h:6109
glTangent3ivEXT = _link_function('glTangent3ivEXT', None, [POINTER(GLint)], 'EXT_coordinate_frame')
# GL/glext.h:6110
glTangent3sEXT = _link_function('glTangent3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_coordinate_frame')
# GL/glext.h:6111
glTangent3svEXT = _link_function('glTangent3svEXT', None, [POINTER(GLshort)], 'EXT_coordinate_frame')
# GL/glext.h:6112
glBinormal3bEXT = _link_function('glBinormal3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_coordinate_frame')
# GL/glext.h:6113
glBinormal3bvEXT = _link_function('glBinormal3bvEXT', None, [POINTER(GLbyte)], 'EXT_coordinate_frame')
# GL/glext.h:6114
glBinormal3dEXT = _link_function('glBinormal3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_coordinate_frame')
# GL/glext.h:6115
glBinormal3dvEXT = _link_function('glBinormal3dvEXT', None, [POINTER(GLdouble)], 'EXT_coordinate_frame')
# GL/glext.h:6116
glBinormal3fEXT = _link_function('glBinormal3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_coordinate_frame')
# GL/glext.h:6117
glBinormal3fvEXT = _link_function('glBinormal3fvEXT', None, [POINTER(GLfloat)], 'EXT_coordinate_frame')
# GL/glext.h:6118
glBinormal3iEXT = _link_function('glBinormal3iEXT', None, [GLint, GLint, GLint], 'EXT_coordinate_frame')
# GL/glext.h:6119
glBinormal3ivEXT = _link_function('glBinormal3ivEXT', None, [POINTER(GLint)], 'EXT_coordinate_frame')
# GL/glext.h:6120
glBinormal3sEXT = _link_function('glBinormal3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_coordinate_frame')
# GL/glext.h:6121
glBinormal3svEXT = _link_function('glBinormal3svEXT', None, [POINTER(GLshort)], 'EXT_coordinate_frame')
# GL/glext.h:6122
glTangentPointerEXT = _link_function('glTangentPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_coordinate_frame')
# GL/glext.h:6123
glBinormalPointerEXT = _link_function('glBinormalPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_coordinate_frame')
PFNGLTANGENT3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:6125
PFNGLTANGENT3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:6126
PFNGLTANGENT3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:6127
PFNGLTANGENT3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6128
PFNGLTANGENT3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:6129
PFNGLTANGENT3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6130
PFNGLTANGENT3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6131
PFNGLTANGENT3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6132
PFNGLTANGENT3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:6133
PFNGLTANGENT3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6134
PFNGLBINORMAL3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:6135
PFNGLBINORMAL3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:6136
PFNGLBINORMAL3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:6137
PFNGLBINORMAL3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6138
PFNGLBINORMAL3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:6139
PFNGLBINORMAL3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6140
PFNGLBINORMAL3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6141
PFNGLBINORMAL3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6142
PFNGLBINORMAL3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:6143
PFNGLBINORMAL3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6144
PFNGLTANGENTPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6145
PFNGLBINORMALPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6146
# EXT_texture_env_combine (GL/glext.h:6149)
GL_EXT_texture_env_combine = 1 # GL/glext.h:6150
# APPLE_specular_vector (GL/glext.h:6153)
GL_APPLE_specular_vector = 1 # GL/glext.h:6154
# APPLE_transform_hint (GL/glext.h:6157)
GL_APPLE_transform_hint = 1 # GL/glext.h:6158
# SGIX_fog_scale (GL/glext.h:6161)
GL_SGIX_fog_scale = 1 # GL/glext.h:6162
# SUNX_constant_data (GL/glext.h:6165)
GL_SUNX_constant_data = 1 # GL/glext.h:6166
# GL/glext.h:6168
glFinishTextureSUNX = _link_function('glFinishTextureSUNX', None, [], 'SUNX_constant_data')
PFNGLFINISHTEXTURESUNXPROC = CFUNCTYPE(None) # GL/glext.h:6170
# SUN_global_alpha (GL/glext.h:6173)
GL_SUN_global_alpha = 1 # GL/glext.h:6174
# GL/glext.h:6176
glGlobalAlphaFactorbSUN = _link_function('glGlobalAlphaFactorbSUN', None, [GLbyte], 'SUN_global_alpha')
# GL/glext.h:6177
glGlobalAlphaFactorsSUN = _link_function('glGlobalAlphaFactorsSUN', None, [GLshort], 'SUN_global_alpha')
# GL/glext.h:6178
glGlobalAlphaFactoriSUN = _link_function('glGlobalAlphaFactoriSUN', None, [GLint], 'SUN_global_alpha')
# GL/glext.h:6179
glGlobalAlphaFactorfSUN = _link_function('glGlobalAlphaFactorfSUN', None, [GLfloat], 'SUN_global_alpha')
# GL/glext.h:6180
glGlobalAlphaFactordSUN = _link_function('glGlobalAlphaFactordSUN', None, [GLdouble], 'SUN_global_alpha')
# GL/glext.h:6181
glGlobalAlphaFactorubSUN = _link_function('glGlobalAlphaFactorubSUN', None, [GLubyte], 'SUN_global_alpha')
# GL/glext.h:6182
glGlobalAlphaFactorusSUN = _link_function('glGlobalAlphaFactorusSUN', None, [GLushort], 'SUN_global_alpha')
# GL/glext.h:6183
glGlobalAlphaFactoruiSUN = _link_function('glGlobalAlphaFactoruiSUN', None, [GLuint], 'SUN_global_alpha')
PFNGLGLOBALALPHAFACTORBSUNPROC = CFUNCTYPE(None, GLbyte) # GL/glext.h:6185
PFNGLGLOBALALPHAFACTORSSUNPROC = CFUNCTYPE(None, GLshort) # GL/glext.h:6186
PFNGLGLOBALALPHAFACTORISUNPROC = CFUNCTYPE(None, GLint) # GL/glext.h:6187
PFNGLGLOBALALPHAFACTORFSUNPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:6188
PFNGLGLOBALALPHAFACTORDSUNPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:6189
PFNGLGLOBALALPHAFACTORUBSUNPROC = CFUNCTYPE(None, GLubyte) # GL/glext.h:6190
PFNGLGLOBALALPHAFACTORUSSUNPROC = CFUNCTYPE(None, GLushort) # GL/glext.h:6191
PFNGLGLOBALALPHAFACTORUISUNPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6192
# SUN_triangle_list (GL/glext.h:6195)
GL_SUN_triangle_list = 1 # GL/glext.h:6196
# GL/glext.h:6198
glReplacementCodeuiSUN = _link_function('glReplacementCodeuiSUN', None, [GLuint], 'SUN_triangle_list')
# GL/glext.h:6199
glReplacementCodeusSUN = _link_function('glReplacementCodeusSUN', None, [GLushort], 'SUN_triangle_list')
# GL/glext.h:6200
glReplacementCodeubSUN = _link_function('glReplacementCodeubSUN', None, [GLubyte], 'SUN_triangle_list')
# GL/glext.h:6201
glReplacementCodeuivSUN = _link_function('glReplacementCodeuivSUN', None, [POINTER(GLuint)], 'SUN_triangle_list')
# GL/glext.h:6202
glReplacementCodeusvSUN = _link_function('glReplacementCodeusvSUN', None, [POINTER(GLushort)], 'SUN_triangle_list')
# GL/glext.h:6203
glReplacementCodeubvSUN = _link_function('glReplacementCodeubvSUN', None, [POINTER(GLubyte)], 'SUN_triangle_list')
# GL/glext.h:6204
glReplacementCodePointerSUN = _link_function('glReplacementCodePointerSUN', None, [GLenum, GLsizei, POINTER(POINTER(GLvoid))], 'SUN_triangle_list')
PFNGLREPLACEMENTCODEUISUNPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6206
PFNGLREPLACEMENTCODEUSSUNPROC = CFUNCTYPE(None, GLushort) # GL/glext.h:6207
PFNGLREPLACEMENTCODEUBSUNPROC = CFUNCTYPE(None, GLubyte) # GL/glext.h:6208
PFNGLREPLACEMENTCODEUIVSUNPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:6209
PFNGLREPLACEMENTCODEUSVSUNPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:6210
PFNGLREPLACEMENTCODEUBVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:6211
PFNGLREPLACEMENTCODEPOINTERSUNPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(POINTER(GLvoid))) # GL/glext.h:6212
# SUN_vertex (GL/glext.h:6215)
GL_SUN_vertex = 1 # GL/glext.h:6216
# GL/glext.h:6218
glColor4ubVertex2fSUN = _link_function('glColor4ubVertex2fSUN', None, [GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6219
glColor4ubVertex2fvSUN = _link_function('glColor4ubVertex2fvSUN', None, [POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6220
glColor4ubVertex3fSUN = _link_function('glColor4ubVertex3fSUN', None, [GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6221
glColor4ubVertex3fvSUN = _link_function('glColor4ubVertex3fvSUN', None, [POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6222
glColor3fVertex3fSUN = _link_function('glColor3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6223
glColor3fVertex3fvSUN = _link_function('glColor3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6224
glNormal3fVertex3fSUN = _link_function('glNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6225
glNormal3fVertex3fvSUN = _link_function('glNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6226
glColor4fNormal3fVertex3fSUN = _link_function('glColor4fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6227
glColor4fNormal3fVertex3fvSUN = _link_function('glColor4fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6228
glTexCoord2fVertex3fSUN = _link_function('glTexCoord2fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6229
glTexCoord2fVertex3fvSUN = _link_function('glTexCoord2fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6230
glTexCoord4fVertex4fSUN = _link_function('glTexCoord4fVertex4fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6231
glTexCoord4fVertex4fvSUN = _link_function('glTexCoord4fVertex4fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6232
glTexCoord2fColor4ubVertex3fSUN = _link_function('glTexCoord2fColor4ubVertex3fSUN', None, [GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6233
glTexCoord2fColor4ubVertex3fvSUN = _link_function('glTexCoord2fColor4ubVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6234
glTexCoord2fColor3fVertex3fSUN = _link_function('glTexCoord2fColor3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6235
glTexCoord2fColor3fVertex3fvSUN = _link_function('glTexCoord2fColor3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6236
glTexCoord2fNormal3fVertex3fSUN = _link_function('glTexCoord2fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6237
glTexCoord2fNormal3fVertex3fvSUN = _link_function('glTexCoord2fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6238
glTexCoord2fColor4fNormal3fVertex3fSUN = _link_function('glTexCoord2fColor4fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6239
glTexCoord2fColor4fNormal3fVertex3fvSUN = _link_function('glTexCoord2fColor4fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6240
glTexCoord4fColor4fNormal3fVertex4fSUN = _link_function('glTexCoord4fColor4fNormal3fVertex4fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6241
glTexCoord4fColor4fNormal3fVertex4fvSUN = _link_function('glTexCoord4fColor4fNormal3fVertex4fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6242
glReplacementCodeuiVertex3fSUN = _link_function('glReplacementCodeuiVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6243
glReplacementCodeuiVertex3fvSUN = _link_function('glReplacementCodeuiVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6244
glReplacementCodeuiColor4ubVertex3fSUN = _link_function('glReplacementCodeuiColor4ubVertex3fSUN', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6245
glReplacementCodeuiColor4ubVertex3fvSUN = _link_function('glReplacementCodeuiColor4ubVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6246
glReplacementCodeuiColor3fVertex3fSUN = _link_function('glReplacementCodeuiColor3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6247
glReplacementCodeuiColor3fVertex3fvSUN = _link_function('glReplacementCodeuiColor3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6248
glReplacementCodeuiNormal3fVertex3fSUN = _link_function('glReplacementCodeuiNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6249
glReplacementCodeuiNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6250
glReplacementCodeuiColor4fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiColor4fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6251
glReplacementCodeuiColor4fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiColor4fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6252
glReplacementCodeuiTexCoord2fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6253
glReplacementCodeuiTexCoord2fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6254
glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6255
glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:6256
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:6257
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
PFNGLCOLOR4UBVERTEX2FSUNPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat) # GL/glext.h:6259
PFNGLCOLOR4UBVERTEX2FVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:6260
PFNGLCOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:6261
PFNGLCOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:6262
PFNGLCOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6263
PFNGLCOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6264
PFNGLNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6265
PFNGLNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6266
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6267
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6268
PFNGLTEXCOORD2FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6269
PFNGLTEXCOORD2FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6270
PFNGLTEXCOORD4FVERTEX4FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6271
PFNGLTEXCOORD4FVERTEX4FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6272
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:6273
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:6274
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6275
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6276
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6277
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6278
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6279
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6280
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6281
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6282
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6283
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat)) # GL/glext.h:6284
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:6285
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:6286
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6287
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6288
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6289
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6290
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6291
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6292
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6293
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6294
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6295
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6296
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6297
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:6298
# EXT_blend_func_separate (GL/glext.h:6301)
GL_EXT_blend_func_separate = 1 # GL/glext.h:6302
# GL/glext.h:6304
glBlendFuncSeparateEXT = _link_function('glBlendFuncSeparateEXT', None, [GLenum, GLenum, GLenum, GLenum], 'EXT_blend_func_separate')
PFNGLBLENDFUNCSEPARATEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6306
# INGR_blend_func_separate (GL/glext.h:6309)
GL_INGR_blend_func_separate = 1 # GL/glext.h:6310
# GL/glext.h:6312
glBlendFuncSeparateINGR = _link_function('glBlendFuncSeparateINGR', None, [GLenum, GLenum, GLenum, GLenum], 'INGR_blend_func_separate')
PFNGLBLENDFUNCSEPARATEINGRPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6314
# INGR_color_clamp (GL/glext.h:6317)
GL_INGR_color_clamp = 1 # GL/glext.h:6318
# INGR_interlace_read (GL/glext.h:6321)
GL_INGR_interlace_read = 1 # GL/glext.h:6322
# EXT_stencil_wrap (GL/glext.h:6325)
GL_EXT_stencil_wrap = 1 # GL/glext.h:6326
# EXT_422_pixels (GL/glext.h:6329)
GL_EXT_422_pixels = 1 # GL/glext.h:6330
# NV_texgen_reflection (GL/glext.h:6333)
GL_NV_texgen_reflection = 1 # GL/glext.h:6334
# SUN_convolution_border_modes (GL/glext.h:6337)
GL_SUN_convolution_border_modes = 1 # GL/glext.h:6338
# EXT_texture_env_add (GL/glext.h:6341)
GL_EXT_texture_env_add = 1 # GL/glext.h:6342
# EXT_texture_lod_bias (GL/glext.h:6345)
GL_EXT_texture_lod_bias = 1 # GL/glext.h:6346
# EXT_texture_filter_anisotropic (GL/glext.h:6349)
GL_EXT_texture_filter_anisotropic = 1 # GL/glext.h:6350
# EXT_vertex_weighting (GL/glext.h:6353)
GL_EXT_vertex_weighting = 1 # GL/glext.h:6354
# GL/glext.h:6356
glVertexWeightfEXT = _link_function('glVertexWeightfEXT', None, [GLfloat], 'EXT_vertex_weighting')
# GL/glext.h:6357
glVertexWeightfvEXT = _link_function('glVertexWeightfvEXT', None, [POINTER(GLfloat)], 'EXT_vertex_weighting')
# GL/glext.h:6358
glVertexWeightPointerEXT = _link_function('glVertexWeightPointerEXT', None, [GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_vertex_weighting')
PFNGLVERTEXWEIGHTFEXTPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:6360
PFNGLVERTEXWEIGHTFVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6361
PFNGLVERTEXWEIGHTPOINTEREXTPROC = CFUNCTYPE(None, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6362
# NV_light_max_exponent (GL/glext.h:6365)
GL_NV_light_max_exponent = 1 # GL/glext.h:6366
# NV_vertex_array_range (GL/glext.h:6369)
GL_NV_vertex_array_range = 1 # GL/glext.h:6370
# GL/glext.h:6372
glFlushVertexArrayRangeNV = _link_function('glFlushVertexArrayRangeNV', None, [], 'NV_vertex_array_range')
# GL/glext.h:6373
glVertexArrayRangeNV = _link_function('glVertexArrayRangeNV', None, [GLsizei, POINTER(GLvoid)], 'NV_vertex_array_range')
PFNGLFLUSHVERTEXARRAYRANGENVPROC = CFUNCTYPE(None) # GL/glext.h:6375
PFNGLVERTEXARRAYRANGENVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:6376
# NV_register_combiners (GL/glext.h:6379)
GL_NV_register_combiners = 1 # GL/glext.h:6380
# GL/glext.h:6382
glCombinerParameterfvNV = _link_function('glCombinerParameterfvNV', None, [GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:6383
glCombinerParameterfNV = _link_function('glCombinerParameterfNV', None, [GLenum, GLfloat], 'NV_register_combiners')
# GL/glext.h:6384
glCombinerParameterivNV = _link_function('glCombinerParameterivNV', None, [GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:6385
glCombinerParameteriNV = _link_function('glCombinerParameteriNV', None, [GLenum, GLint], 'NV_register_combiners')
# GL/glext.h:6386
glCombinerInputNV = _link_function('glCombinerInputNV', None, [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum], 'NV_register_combiners')
# GL/glext.h:6387
glCombinerOutputNV = _link_function('glCombinerOutputNV', None, [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean], 'NV_register_combiners')
# GL/glext.h:6388
glFinalCombinerInputNV = _link_function('glFinalCombinerInputNV', None, [GLenum, GLenum, GLenum, GLenum], 'NV_register_combiners')
# GL/glext.h:6389
glGetCombinerInputParameterfvNV = _link_function('glGetCombinerInputParameterfvNV', None, [GLenum, GLenum, GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:6390
glGetCombinerInputParameterivNV = _link_function('glGetCombinerInputParameterivNV', None, [GLenum, GLenum, GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:6391
glGetCombinerOutputParameterfvNV = _link_function('glGetCombinerOutputParameterfvNV', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:6392
glGetCombinerOutputParameterivNV = _link_function('glGetCombinerOutputParameterivNV', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:6393
glGetFinalCombinerInputParameterfvNV = _link_function('glGetFinalCombinerInputParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:6394
glGetFinalCombinerInputParameterivNV = _link_function('glGetFinalCombinerInputParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
PFNGLCOMBINERPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:6396
PFNGLCOMBINERPARAMETERFNVPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:6397
PFNGLCOMBINERPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:6398
PFNGLCOMBINERPARAMETERINVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:6399
PFNGLCOMBINERINPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6400
PFNGLCOMBINEROUTPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean) # GL/glext.h:6401
PFNGLFINALCOMBINERINPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6402
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6403
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6404
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6405
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6406
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6407
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6408
# NV_fog_distance (GL/glext.h:6411)
GL_NV_fog_distance = 1 # GL/glext.h:6412
# NV_texgen_emboss (GL/glext.h:6415)
GL_NV_texgen_emboss = 1 # GL/glext.h:6416
# NV_blend_square (GL/glext.h:6419)
GL_NV_blend_square = 1 # GL/glext.h:6420
# NV_texture_env_combine4 (GL/glext.h:6423)
GL_NV_texture_env_combine4 = 1 # GL/glext.h:6424
# MESA_resize_buffers (GL/glext.h:6427)
GL_MESA_resize_buffers = 1 # GL/glext.h:6428
# GL/glext.h:6430
glResizeBuffersMESA = _link_function('glResizeBuffersMESA', None, [], 'MESA_resize_buffers')
PFNGLRESIZEBUFFERSMESAPROC = CFUNCTYPE(None) # GL/glext.h:6432
# MESA_window_pos (GL/glext.h:6435)
GL_MESA_window_pos = 1 # GL/glext.h:6436
# GL/glext.h:6438
glWindowPos2dMESA = _link_function('glWindowPos2dMESA', None, [GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:6439
glWindowPos2dvMESA = _link_function('glWindowPos2dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:6440
glWindowPos2fMESA = _link_function('glWindowPos2fMESA', None, [GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:6441
glWindowPos2fvMESA = _link_function('glWindowPos2fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:6442
glWindowPos2iMESA = _link_function('glWindowPos2iMESA', None, [GLint, GLint], 'MESA_window_pos')
# GL/glext.h:6443
glWindowPos2ivMESA = _link_function('glWindowPos2ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:6444
glWindowPos2sMESA = _link_function('glWindowPos2sMESA', None, [GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:6445
glWindowPos2svMESA = _link_function('glWindowPos2svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
# GL/glext.h:6446
glWindowPos3dMESA = _link_function('glWindowPos3dMESA', None, [GLdouble, GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:6447
glWindowPos3dvMESA = _link_function('glWindowPos3dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:6448
glWindowPos3fMESA = _link_function('glWindowPos3fMESA', None, [GLfloat, GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:6449
glWindowPos3fvMESA = _link_function('glWindowPos3fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:6450
glWindowPos3iMESA = _link_function('glWindowPos3iMESA', None, [GLint, GLint, GLint], 'MESA_window_pos')
# GL/glext.h:6451
glWindowPos3ivMESA = _link_function('glWindowPos3ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:6452
glWindowPos3sMESA = _link_function('glWindowPos3sMESA', None, [GLshort, GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:6453
glWindowPos3svMESA = _link_function('glWindowPos3svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
# GL/glext.h:6454
glWindowPos4dMESA = _link_function('glWindowPos4dMESA', None, [GLdouble, GLdouble, GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:6455
glWindowPos4dvMESA = _link_function('glWindowPos4dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:6456
glWindowPos4fMESA = _link_function('glWindowPos4fMESA', None, [GLfloat, GLfloat, GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:6457
glWindowPos4fvMESA = _link_function('glWindowPos4fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:6458
glWindowPos4iMESA = _link_function('glWindowPos4iMESA', None, [GLint, GLint, GLint, GLint], 'MESA_window_pos')
# GL/glext.h:6459
glWindowPos4ivMESA = _link_function('glWindowPos4ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:6460
glWindowPos4sMESA = _link_function('glWindowPos4sMESA', None, [GLshort, GLshort, GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:6461
glWindowPos4svMESA = _link_function('glWindowPos4svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
PFNGLWINDOWPOS2DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:6463
PFNGLWINDOWPOS2DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6464
PFNGLWINDOWPOS2FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:6465
PFNGLWINDOWPOS2FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6466
PFNGLWINDOWPOS2IMESAPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:6467
PFNGLWINDOWPOS2IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6468
PFNGLWINDOWPOS2SMESAPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:6469
PFNGLWINDOWPOS2SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6470
PFNGLWINDOWPOS3DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:6471
PFNGLWINDOWPOS3DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6472
PFNGLWINDOWPOS3FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:6473
PFNGLWINDOWPOS3FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6474
PFNGLWINDOWPOS3IMESAPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6475
PFNGLWINDOWPOS3IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6476
PFNGLWINDOWPOS3SMESAPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:6477
PFNGLWINDOWPOS3SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6478
PFNGLWINDOWPOS4DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6479
PFNGLWINDOWPOS4DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6480
PFNGLWINDOWPOS4FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6481
PFNGLWINDOWPOS4FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6482
PFNGLWINDOWPOS4IMESAPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:6483
PFNGLWINDOWPOS4IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6484
PFNGLWINDOWPOS4SMESAPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:6485
PFNGLWINDOWPOS4SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6486
# EXT_texture_compression_s3tc (GL/glext.h:6489)
GL_EXT_texture_compression_s3tc = 1 # GL/glext.h:6490
# IBM_cull_vertex (GL/glext.h:6493)
GL_IBM_cull_vertex = 1 # GL/glext.h:6494
# IBM_multimode_draw_arrays (GL/glext.h:6497)
GL_IBM_multimode_draw_arrays = 1 # GL/glext.h:6498
# GL/glext.h:6500
glMultiModeDrawArraysIBM = _link_function('glMultiModeDrawArraysIBM', None, [POINTER(GLenum), POINTER(GLint), POINTER(GLsizei), GLsizei, GLint], 'IBM_multimode_draw_arrays')
# GL/glext.h:6501
glMultiModeDrawElementsIBM = _link_function('glMultiModeDrawElementsIBM', None, [POINTER(GLenum), POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, GLint], 'IBM_multimode_draw_arrays')
PFNGLMULTIMODEDRAWARRAYSIBMPROC = CFUNCTYPE(None, POINTER(GLenum), POINTER(GLint), POINTER(GLsizei), GLsizei, GLint) # GL/glext.h:6503
PFNGLMULTIMODEDRAWELEMENTSIBMPROC = CFUNCTYPE(None, POINTER(GLenum), POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, GLint) # GL/glext.h:6504
# IBM_vertex_array_lists (GL/glext.h:6507)
GL_IBM_vertex_array_lists = 1 # GL/glext.h:6508
# GL/glext.h:6510
glColorPointerListIBM = _link_function('glColorPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6511
glSecondaryColorPointerListIBM = _link_function('glSecondaryColorPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6512
glEdgeFlagPointerListIBM = _link_function('glEdgeFlagPointerListIBM', None, [GLint, POINTER(POINTER(GLboolean)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6513
glFogCoordPointerListIBM = _link_function('glFogCoordPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6514
glIndexPointerListIBM = _link_function('glIndexPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6515
glNormalPointerListIBM = _link_function('glNormalPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6516
glTexCoordPointerListIBM = _link_function('glTexCoordPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:6517
glVertexPointerListIBM = _link_function('glVertexPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
PFNGLCOLORPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6519
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6520
PFNGLEDGEFLAGPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, POINTER(POINTER(GLboolean)), GLint) # GL/glext.h:6521
PFNGLFOGCOORDPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6522
PFNGLINDEXPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6523
PFNGLNORMALPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6524
PFNGLTEXCOORDPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6525
PFNGLVERTEXPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:6526
# SGIX_subsample (GL/glext.h:6529)
GL_SGIX_subsample = 1 # GL/glext.h:6530
# SGIX_ycrcba (GL/glext.h:6533)
GL_SGIX_ycrcba = 1 # GL/glext.h:6534
# SGIX_ycrcb_subsample (GL/glext.h:6537)
GL_SGIX_ycrcb_subsample = 1 # GL/glext.h:6538
# SGIX_depth_pass_instrument (GL/glext.h:6541)
GL_SGIX_depth_pass_instrument = 1 # GL/glext.h:6542
# 3DFX_texture_compression_FXT1 (GL/glext.h:6545)
GL_3DFX_texture_compression_FXT1 = 1 # GL/glext.h:6546
# 3DFX_multisample (GL/glext.h:6549)
GL_3DFX_multisample = 1 # GL/glext.h:6550
# 3DFX_tbuffer (GL/glext.h:6553)
GL_3DFX_tbuffer = 1 # GL/glext.h:6554
# GL/glext.h:6556
glTbufferMask3DFX = _link_function('glTbufferMask3DFX', None, [GLuint], '3DFX_tbuffer')
PFNGLTBUFFERMASK3DFXPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6558
# EXT_multisample (GL/glext.h:6561)
GL_EXT_multisample = 1 # GL/glext.h:6562
# GL/glext.h:6564
glSampleMaskEXT = _link_function('glSampleMaskEXT', None, [GLclampf, GLboolean], 'EXT_multisample')
# GL/glext.h:6565
glSamplePatternEXT = _link_function('glSamplePatternEXT', None, [GLenum], 'EXT_multisample')
PFNGLSAMPLEMASKEXTPROC = CFUNCTYPE(None, GLclampf, GLboolean) # GL/glext.h:6567
PFNGLSAMPLEPATTERNEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:6568
# SGIX_vertex_preclip (GL/glext.h:6571)
GL_SGIX_vertex_preclip = 1 # GL/glext.h:6572
# SGIX_convolution_accuracy (GL/glext.h:6575)
GL_SGIX_convolution_accuracy = 1 # GL/glext.h:6576
# SGIX_resample (GL/glext.h:6579)
GL_SGIX_resample = 1 # GL/glext.h:6580
# SGIS_point_line_texgen (GL/glext.h:6583)
GL_SGIS_point_line_texgen = 1 # GL/glext.h:6584
# SGIS_texture_color_mask (GL/glext.h:6587)
GL_SGIS_texture_color_mask = 1 # GL/glext.h:6588
# GL/glext.h:6590
glTextureColorMaskSGIS = _link_function('glTextureColorMaskSGIS', None, [GLboolean, GLboolean, GLboolean, GLboolean], 'SGIS_texture_color_mask')
PFNGLTEXTURECOLORMASKSGISPROC = CFUNCTYPE(None, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:6592
# SGIX_igloo_interface (GL/glext.h:6595)
GL_SGIX_igloo_interface = 1 # GL/glext.h:6596
# GL/glext.h:6598
glIglooInterfaceSGIX = _link_function('glIglooInterfaceSGIX', None, [GLenum, POINTER(GLvoid)], 'SGIX_igloo_interface')
PFNGLIGLOOINTERFACESGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:6600
# EXT_texture_env_dot3 (GL/glext.h:6603)
GL_EXT_texture_env_dot3 = 1 # GL/glext.h:6604
# ATI_texture_mirror_once (GL/glext.h:6607)
GL_ATI_texture_mirror_once = 1 # GL/glext.h:6608
# NV_fence (GL/glext.h:6611)
GL_NV_fence = 1 # GL/glext.h:6612
# GL/glext.h:6614
glDeleteFencesNV = _link_function('glDeleteFencesNV', None, [GLsizei, POINTER(GLuint)], 'NV_fence')
# GL/glext.h:6615
glGenFencesNV = _link_function('glGenFencesNV', None, [GLsizei, POINTER(GLuint)], 'NV_fence')
# GL/glext.h:6616
glIsFenceNV = _link_function('glIsFenceNV', GLboolean, [GLuint], 'NV_fence')
# GL/glext.h:6617
glTestFenceNV = _link_function('glTestFenceNV', GLboolean, [GLuint], 'NV_fence')
# GL/glext.h:6618
glGetFenceivNV = _link_function('glGetFenceivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_fence')
# GL/glext.h:6619
glFinishFenceNV = _link_function('glFinishFenceNV', None, [GLuint], 'NV_fence')
# GL/glext.h:6620
glSetFenceNV = _link_function('glSetFenceNV', None, [GLuint, GLenum], 'NV_fence')
PFNGLDELETEFENCESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6622
PFNGLGENFENCESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6623
PFNGLISFENCENVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6624
PFNGLTESTFENCENVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6625
PFNGLGETFENCEIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6626
PFNGLFINISHFENCENVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6627
PFNGLSETFENCENVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:6628
# NV_evaluators (GL/glext.h:6631)
GL_NV_evaluators = 1 # GL/glext.h:6632
# GL/glext.h:6634
glMapControlPointsNV = _link_function('glMapControlPointsNV', None, [GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, POINTER(GLvoid)], 'NV_evaluators')
# GL/glext.h:6635
glMapParameterivNV = _link_function('glMapParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:6636
glMapParameterfvNV = _link_function('glMapParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:6637
glGetMapControlPointsNV = _link_function('glGetMapControlPointsNV', None, [GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, POINTER(GLvoid)], 'NV_evaluators')
# GL/glext.h:6638
glGetMapParameterivNV = _link_function('glGetMapParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:6639
glGetMapParameterfvNV = _link_function('glGetMapParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:6640
glGetMapAttribParameterivNV = _link_function('glGetMapAttribParameterivNV', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:6641
glGetMapAttribParameterfvNV = _link_function('glGetMapAttribParameterfvNV', None, [GLenum, GLuint, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:6642
glEvalMapsNV = _link_function('glEvalMapsNV', None, [GLenum, GLenum], 'NV_evaluators')
PFNGLMAPCONTROLPOINTSNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, POINTER(GLvoid)) # GL/glext.h:6644
PFNGLMAPPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6645
PFNGLMAPPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6646
PFNGLGETMAPCONTROLPOINTSNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, POINTER(GLvoid)) # GL/glext.h:6647
PFNGLGETMAPPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6648
PFNGLGETMAPPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6649
PFNGLGETMAPATTRIBPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6650
PFNGLGETMAPATTRIBPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6651
PFNGLEVALMAPSNVPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:6652
# NV_packed_depth_stencil (GL/glext.h:6655)
GL_NV_packed_depth_stencil = 1 # GL/glext.h:6656
# EXT_packed_depth_stencil (GL/glext.h:6659)
GL_EXT_packed_depth_stencil = 1 # GL/glext.h:6660
# NV_register_combiners2 (GL/glext.h:6663)
GL_NV_register_combiners2 = 1 # GL/glext.h:6664
# GL/glext.h:6666
glCombinerStageParameterfvNV = _link_function('glCombinerStageParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners2')
# GL/glext.h:6667
glGetCombinerStageParameterfvNV = _link_function('glGetCombinerStageParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners2')
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6669
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6670
# NV_texture_compression_vtc (GL/glext.h:6673)
GL_NV_texture_compression_vtc = 1 # GL/glext.h:6674
# NV_texture_rectangle (GL/glext.h:6677)
GL_NV_texture_rectangle = 1 # GL/glext.h:6678
# NV_texture_shader (GL/glext.h:6681)
GL_NV_texture_shader = 1 # GL/glext.h:6682
# NV_texture_shader2 (GL/glext.h:6685)
GL_NV_texture_shader2 = 1 # GL/glext.h:6686
# NV_vertex_array_range2 (GL/glext.h:6689)
GL_NV_vertex_array_range2 = 1 # GL/glext.h:6690
# NV_vertex_program (GL/glext.h:6693)
GL_NV_vertex_program = 1 # GL/glext.h:6694
# GL/glext.h:6696
glAreProgramsResidentNV = _link_function('glAreProgramsResidentNV', GLboolean, [GLsizei, POINTER(GLuint), POINTER(GLboolean)], 'NV_vertex_program')
# GL/glext.h:6697
glBindProgramNV = _link_function('glBindProgramNV', None, [GLenum, GLuint], 'NV_vertex_program')
# GL/glext.h:6698
glDeleteProgramsNV = _link_function('glDeleteProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:6699
glExecuteProgramNV = _link_function('glExecuteProgramNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6700
glGenProgramsNV = _link_function('glGenProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:6701
glGetProgramParameterdvNV = _link_function('glGetProgramParameterdvNV', None, [GLenum, GLuint, GLenum, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6702
glGetProgramParameterfvNV = _link_function('glGetProgramParameterfvNV', None, [GLenum, GLuint, GLenum, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6703
glGetProgramivNV = _link_function('glGetProgramivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:6704
glGetProgramStringNV = _link_function('glGetProgramStringNV', None, [GLuint, GLenum, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:6705
glGetTrackMatrixivNV = _link_function('glGetTrackMatrixivNV', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:6706
glGetVertexAttribdvNV = _link_function('glGetVertexAttribdvNV', None, [GLuint, GLenum, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6707
glGetVertexAttribfvNV = _link_function('glGetVertexAttribfvNV', None, [GLuint, GLenum, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6708
glGetVertexAttribivNV = _link_function('glGetVertexAttribivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:6709
glGetVertexAttribPointervNV = _link_function('glGetVertexAttribPointervNV', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'NV_vertex_program')
# GL/glext.h:6710
glIsProgramNV = _link_function('glIsProgramNV', GLboolean, [GLuint], 'NV_vertex_program')
# GL/glext.h:6711
glLoadProgramNV = _link_function('glLoadProgramNV', None, [GLenum, GLuint, GLsizei, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:6712
glProgramParameter4dNV = _link_function('glProgramParameter4dNV', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:6713
glProgramParameter4dvNV = _link_function('glProgramParameter4dvNV', None, [GLenum, GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6714
glProgramParameter4fNV = _link_function('glProgramParameter4fNV', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:6715
glProgramParameter4fvNV = _link_function('glProgramParameter4fvNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6716
glProgramParameters4dvNV = _link_function('glProgramParameters4dvNV', None, [GLenum, GLuint, GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6717
glProgramParameters4fvNV = _link_function('glProgramParameters4fvNV', None, [GLenum, GLuint, GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6718
glRequestResidentProgramsNV = _link_function('glRequestResidentProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:6719
glTrackMatrixNV = _link_function('glTrackMatrixNV', None, [GLenum, GLuint, GLenum, GLenum], 'NV_vertex_program')
# GL/glext.h:6720
glVertexAttribPointerNV = _link_function('glVertexAttribPointerNV', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'NV_vertex_program')
# GL/glext.h:6721
glVertexAttrib1dNV = _link_function('glVertexAttrib1dNV', None, [GLuint, GLdouble], 'NV_vertex_program')
# GL/glext.h:6722
glVertexAttrib1dvNV = _link_function('glVertexAttrib1dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6723
glVertexAttrib1fNV = _link_function('glVertexAttrib1fNV', None, [GLuint, GLfloat], 'NV_vertex_program')
# GL/glext.h:6724
glVertexAttrib1fvNV = _link_function('glVertexAttrib1fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6725
glVertexAttrib1sNV = _link_function('glVertexAttrib1sNV', None, [GLuint, GLshort], 'NV_vertex_program')
# GL/glext.h:6726
glVertexAttrib1svNV = _link_function('glVertexAttrib1svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6727
glVertexAttrib2dNV = _link_function('glVertexAttrib2dNV', None, [GLuint, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:6728
glVertexAttrib2dvNV = _link_function('glVertexAttrib2dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6729
glVertexAttrib2fNV = _link_function('glVertexAttrib2fNV', None, [GLuint, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:6730
glVertexAttrib2fvNV = _link_function('glVertexAttrib2fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6731
glVertexAttrib2sNV = _link_function('glVertexAttrib2sNV', None, [GLuint, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:6732
glVertexAttrib2svNV = _link_function('glVertexAttrib2svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6733
glVertexAttrib3dNV = _link_function('glVertexAttrib3dNV', None, [GLuint, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:6734
glVertexAttrib3dvNV = _link_function('glVertexAttrib3dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6735
glVertexAttrib3fNV = _link_function('glVertexAttrib3fNV', None, [GLuint, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:6736
glVertexAttrib3fvNV = _link_function('glVertexAttrib3fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6737
glVertexAttrib3sNV = _link_function('glVertexAttrib3sNV', None, [GLuint, GLshort, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:6738
glVertexAttrib3svNV = _link_function('glVertexAttrib3svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6739
glVertexAttrib4dNV = _link_function('glVertexAttrib4dNV', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:6740
glVertexAttrib4dvNV = _link_function('glVertexAttrib4dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6741
glVertexAttrib4fNV = _link_function('glVertexAttrib4fNV', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:6742
glVertexAttrib4fvNV = _link_function('glVertexAttrib4fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6743
glVertexAttrib4sNV = _link_function('glVertexAttrib4sNV', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:6744
glVertexAttrib4svNV = _link_function('glVertexAttrib4svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6745
glVertexAttrib4ubNV = _link_function('glVertexAttrib4ubNV', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'NV_vertex_program')
# GL/glext.h:6746
glVertexAttrib4ubvNV = _link_function('glVertexAttrib4ubvNV', None, [GLuint, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:6747
glVertexAttribs1dvNV = _link_function('glVertexAttribs1dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6748
glVertexAttribs1fvNV = _link_function('glVertexAttribs1fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6749
glVertexAttribs1svNV = _link_function('glVertexAttribs1svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6750
glVertexAttribs2dvNV = _link_function('glVertexAttribs2dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6751
glVertexAttribs2fvNV = _link_function('glVertexAttribs2fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6752
glVertexAttribs2svNV = _link_function('glVertexAttribs2svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6753
glVertexAttribs3dvNV = _link_function('glVertexAttribs3dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6754
glVertexAttribs3fvNV = _link_function('glVertexAttribs3fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6755
glVertexAttribs3svNV = _link_function('glVertexAttribs3svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6756
glVertexAttribs4dvNV = _link_function('glVertexAttribs4dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:6757
glVertexAttribs4fvNV = _link_function('glVertexAttribs4fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:6758
glVertexAttribs4svNV = _link_function('glVertexAttribs4svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:6759
glVertexAttribs4ubvNV = _link_function('glVertexAttribs4ubvNV', None, [GLuint, GLsizei, POINTER(GLubyte)], 'NV_vertex_program')
PFNGLAREPROGRAMSRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLsizei, POINTER(GLuint), POINTER(GLboolean)) # GL/glext.h:6761
PFNGLBINDPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6762
PFNGLDELETEPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6763
PFNGLEXECUTEPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6764
PFNGLGENPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6765
PFNGLGETPROGRAMPARAMETERDVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:6766
PFNGLGETPROGRAMPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6767
PFNGLGETPROGRAMIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6768
PFNGLGETPROGRAMSTRINGNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLubyte)) # GL/glext.h:6769
PFNGLGETTRACKMATRIXIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6770
PFNGLGETVERTEXATTRIBDVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:6771
PFNGLGETVERTEXATTRIBFVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6772
PFNGLGETVERTEXATTRIBIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6773
PFNGLGETVERTEXATTRIBPOINTERVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:6774
PFNGLISPROGRAMNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6775
PFNGLLOADPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLubyte)) # GL/glext.h:6776
PFNGLPROGRAMPARAMETER4DNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6777
PFNGLPROGRAMPARAMETER4DVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:6778
PFNGLPROGRAMPARAMETER4FNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6779
PFNGLPROGRAMPARAMETER4FVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6780
PFNGLPROGRAMPARAMETERS4DVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, POINTER(GLdouble)) # GL/glext.h:6781
PFNGLPROGRAMPARAMETERS4FVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, POINTER(GLfloat)) # GL/glext.h:6782
PFNGLREQUESTRESIDENTPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6783
PFNGLTRACKMATRIXNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLenum) # GL/glext.h:6784
PFNGLVERTEXATTRIBPOINTERNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6785
PFNGLVERTEXATTRIB1DNVPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:6786
PFNGLVERTEXATTRIB1DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6787
PFNGLVERTEXATTRIB1FNVPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:6788
PFNGLVERTEXATTRIB1FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6789
PFNGLVERTEXATTRIB1SNVPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:6790
PFNGLVERTEXATTRIB1SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6791
PFNGLVERTEXATTRIB2DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:6792
PFNGLVERTEXATTRIB2DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6793
PFNGLVERTEXATTRIB2FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:6794
PFNGLVERTEXATTRIB2FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6795
PFNGLVERTEXATTRIB2SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:6796
PFNGLVERTEXATTRIB2SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6797
PFNGLVERTEXATTRIB3DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:6798
PFNGLVERTEXATTRIB3DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6799
PFNGLVERTEXATTRIB3FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6800
PFNGLVERTEXATTRIB3FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6801
PFNGLVERTEXATTRIB3SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:6802
PFNGLVERTEXATTRIB3SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6803
PFNGLVERTEXATTRIB4DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6804
PFNGLVERTEXATTRIB4DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6805
PFNGLVERTEXATTRIB4FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6806
PFNGLVERTEXATTRIB4FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6807
PFNGLVERTEXATTRIB4SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:6808
PFNGLVERTEXATTRIB4SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6809
PFNGLVERTEXATTRIB4UBNVPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:6810
PFNGLVERTEXATTRIB4UBVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6811
PFNGLVERTEXATTRIBS1DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:6812
PFNGLVERTEXATTRIBS1FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6813
PFNGLVERTEXATTRIBS1SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:6814
PFNGLVERTEXATTRIBS2DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:6815
PFNGLVERTEXATTRIBS2FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6816
PFNGLVERTEXATTRIBS2SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:6817
PFNGLVERTEXATTRIBS3DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:6818
PFNGLVERTEXATTRIBS3FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6819
PFNGLVERTEXATTRIBS3SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:6820
PFNGLVERTEXATTRIBS4DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:6821
PFNGLVERTEXATTRIBS4FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6822
PFNGLVERTEXATTRIBS4SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:6823
PFNGLVERTEXATTRIBS4UBVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte)) # GL/glext.h:6824
# SGIX_texture_coordinate_clamp (GL/glext.h:6827)
GL_SGIX_texture_coordinate_clamp = 1 # GL/glext.h:6828
# SGIX_scalebias_hint (GL/glext.h:6831)
GL_SGIX_scalebias_hint = 1 # GL/glext.h:6832
# OML_interlace (GL/glext.h:6835)
GL_OML_interlace = 1 # GL/glext.h:6836
# OML_subsample (GL/glext.h:6839)
GL_OML_subsample = 1 # GL/glext.h:6840
# OML_resample (GL/glext.h:6843)
GL_OML_resample = 1 # GL/glext.h:6844
# NV_copy_depth_to_color (GL/glext.h:6847)
GL_NV_copy_depth_to_color = 1 # GL/glext.h:6848
# ATI_envmap_bumpmap (GL/glext.h:6851)
GL_ATI_envmap_bumpmap = 1 # GL/glext.h:6852
# GL/glext.h:6854
glTexBumpParameterivATI = _link_function('glTexBumpParameterivATI', None, [GLenum, POINTER(GLint)], 'ATI_envmap_bumpmap')
# GL/glext.h:6855
glTexBumpParameterfvATI = _link_function('glTexBumpParameterfvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_envmap_bumpmap')
# GL/glext.h:6856
glGetTexBumpParameterivATI = _link_function('glGetTexBumpParameterivATI', None, [GLenum, POINTER(GLint)], 'ATI_envmap_bumpmap')
# GL/glext.h:6857
glGetTexBumpParameterfvATI = _link_function('glGetTexBumpParameterfvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_envmap_bumpmap')
PFNGLTEXBUMPPARAMETERIVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:6859
PFNGLTEXBUMPPARAMETERFVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:6860
PFNGLGETTEXBUMPPARAMETERIVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:6861
PFNGLGETTEXBUMPPARAMETERFVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:6862
# ATI_fragment_shader (GL/glext.h:6865)
GL_ATI_fragment_shader = 1 # GL/glext.h:6866
# GL/glext.h:6868
glGenFragmentShadersATI = _link_function('glGenFragmentShadersATI', GLuint, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:6869
glBindFragmentShaderATI = _link_function('glBindFragmentShaderATI', None, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:6870
glDeleteFragmentShaderATI = _link_function('glDeleteFragmentShaderATI', None, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:6871
glBeginFragmentShaderATI = _link_function('glBeginFragmentShaderATI', None, [], 'ATI_fragment_shader')
# GL/glext.h:6872
glEndFragmentShaderATI = _link_function('glEndFragmentShaderATI', None, [], 'ATI_fragment_shader')
# GL/glext.h:6873
glPassTexCoordATI = _link_function('glPassTexCoordATI', None, [GLuint, GLuint, GLenum], 'ATI_fragment_shader')
# GL/glext.h:6874
glSampleMapATI = _link_function('glSampleMapATI', None, [GLuint, GLuint, GLenum], 'ATI_fragment_shader')
# GL/glext.h:6875
glColorFragmentOp1ATI = _link_function('glColorFragmentOp1ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6876
glColorFragmentOp2ATI = _link_function('glColorFragmentOp2ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6877
glColorFragmentOp3ATI = _link_function('glColorFragmentOp3ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6878
glAlphaFragmentOp1ATI = _link_function('glAlphaFragmentOp1ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6879
glAlphaFragmentOp2ATI = _link_function('glAlphaFragmentOp2ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6880
glAlphaFragmentOp3ATI = _link_function('glAlphaFragmentOp3ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:6881
glSetFragmentShaderConstantATI = _link_function('glSetFragmentShaderConstantATI', None, [GLuint, POINTER(GLfloat)], 'ATI_fragment_shader')
PFNGLGENFRAGMENTSHADERSATIPROC = CFUNCTYPE(GLuint, GLuint) # GL/glext.h:6883
PFNGLBINDFRAGMENTSHADERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6884
PFNGLDELETEFRAGMENTSHADERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6885
PFNGLBEGINFRAGMENTSHADERATIPROC = CFUNCTYPE(None) # GL/glext.h:6886
PFNGLENDFRAGMENTSHADERATIPROC = CFUNCTYPE(None) # GL/glext.h:6887
PFNGLPASSTEXCOORDATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum) # GL/glext.h:6888
PFNGLSAMPLEMAPATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum) # GL/glext.h:6889
PFNGLCOLORFRAGMENTOP1ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6890
PFNGLCOLORFRAGMENTOP2ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6891
PFNGLCOLORFRAGMENTOP3ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6892
PFNGLALPHAFRAGMENTOP1ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6893
PFNGLALPHAFRAGMENTOP2ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6894
PFNGLALPHAFRAGMENTOP3ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6895
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6896
# ATI_pn_triangles (GL/glext.h:6899)
GL_ATI_pn_triangles = 1 # GL/glext.h:6900
# GL/glext.h:6902
glPNTrianglesiATI = _link_function('glPNTrianglesiATI', None, [GLenum, GLint], 'ATI_pn_triangles')
# GL/glext.h:6903
glPNTrianglesfATI = _link_function('glPNTrianglesfATI', None, [GLenum, GLfloat], 'ATI_pn_triangles')
PFNGLPNTRIANGLESIATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:6905
PFNGLPNTRIANGLESFATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:6906
# ATI_vertex_array_object (GL/glext.h:6909)
GL_ATI_vertex_array_object = 1 # GL/glext.h:6910
# GL/glext.h:6912
glNewObjectBufferATI = _link_function('glNewObjectBufferATI', GLuint, [GLsizei, POINTER(GLvoid), GLenum], 'ATI_vertex_array_object')
# GL/glext.h:6913
glIsObjectBufferATI = _link_function('glIsObjectBufferATI', GLboolean, [GLuint], 'ATI_vertex_array_object')
# GL/glext.h:6914
glUpdateObjectBufferATI = _link_function('glUpdateObjectBufferATI', None, [GLuint, GLuint, GLsizei, POINTER(GLvoid), GLenum], 'ATI_vertex_array_object')
# GL/glext.h:6915
glGetObjectBufferfvATI = _link_function('glGetObjectBufferfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:6916
glGetObjectBufferivATI = _link_function('glGetObjectBufferivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
# GL/glext.h:6917
glFreeObjectBufferATI = _link_function('glFreeObjectBufferATI', None, [GLuint], 'ATI_vertex_array_object')
# GL/glext.h:6918
glArrayObjectATI = _link_function('glArrayObjectATI', None, [GLenum, GLint, GLenum, GLsizei, GLuint, GLuint], 'ATI_vertex_array_object')
# GL/glext.h:6919
glGetArrayObjectfvATI = _link_function('glGetArrayObjectfvATI', None, [GLenum, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:6920
glGetArrayObjectivATI = _link_function('glGetArrayObjectivATI', None, [GLenum, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
# GL/glext.h:6921
glVariantArrayObjectATI = _link_function('glVariantArrayObjectATI', None, [GLuint, GLenum, GLsizei, GLuint, GLuint], 'ATI_vertex_array_object')
# GL/glext.h:6922
glGetVariantArrayObjectfvATI = _link_function('glGetVariantArrayObjectfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:6923
glGetVariantArrayObjectivATI = _link_function('glGetVariantArrayObjectivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
PFNGLNEWOBJECTBUFFERATIPROC = CFUNCTYPE(GLuint, GLsizei, POINTER(GLvoid), GLenum) # GL/glext.h:6925
PFNGLISOBJECTBUFFERATIPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6926
PFNGLUPDATEOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLvoid), GLenum) # GL/glext.h:6927
PFNGLGETOBJECTBUFFERFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6928
PFNGLGETOBJECTBUFFERIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6929
PFNGLFREEOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6930
PFNGLARRAYOBJECTATIPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLuint, GLuint) # GL/glext.h:6931
PFNGLGETARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:6932
PFNGLGETARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6933
PFNGLVARIANTARRAYOBJECTATIPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLuint, GLuint) # GL/glext.h:6934
PFNGLGETVARIANTARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6935
PFNGLGETVARIANTARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6936
# EXT_vertex_shader (GL/glext.h:6939)
GL_EXT_vertex_shader = 1 # GL/glext.h:6940
# GL/glext.h:6942
glBeginVertexShaderEXT = _link_function('glBeginVertexShaderEXT', None, [], 'EXT_vertex_shader')
# GL/glext.h:6943
glEndVertexShaderEXT = _link_function('glEndVertexShaderEXT', None, [], 'EXT_vertex_shader')
# GL/glext.h:6944
glBindVertexShaderEXT = _link_function('glBindVertexShaderEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:6945
glGenVertexShadersEXT = _link_function('glGenVertexShadersEXT', GLuint, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:6946
glDeleteVertexShaderEXT = _link_function('glDeleteVertexShaderEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:6947
glShaderOp1EXT = _link_function('glShaderOp1EXT', None, [GLenum, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6948
glShaderOp2EXT = _link_function('glShaderOp2EXT', None, [GLenum, GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6949
glShaderOp3EXT = _link_function('glShaderOp3EXT', None, [GLenum, GLuint, GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6950
glSwizzleEXT = _link_function('glSwizzleEXT', None, [GLuint, GLuint, GLenum, GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6951
glWriteMaskEXT = _link_function('glWriteMaskEXT', None, [GLuint, GLuint, GLenum, GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6952
glInsertComponentEXT = _link_function('glInsertComponentEXT', None, [GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6953
glExtractComponentEXT = _link_function('glExtractComponentEXT', None, [GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6954
glGenSymbolsEXT = _link_function('glGenSymbolsEXT', GLuint, [GLenum, GLenum, GLenum, GLuint], 'EXT_vertex_shader')
# GL/glext.h:6955
glSetInvariantEXT = _link_function('glSetInvariantEXT', None, [GLuint, GLenum, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:6956
glSetLocalConstantEXT = _link_function('glSetLocalConstantEXT', None, [GLuint, GLenum, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:6957
glVariantbvEXT = _link_function('glVariantbvEXT', None, [GLuint, POINTER(GLbyte)], 'EXT_vertex_shader')
# GL/glext.h:6958
glVariantsvEXT = _link_function('glVariantsvEXT', None, [GLuint, POINTER(GLshort)], 'EXT_vertex_shader')
# GL/glext.h:6959
glVariantivEXT = _link_function('glVariantivEXT', None, [GLuint, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:6960
glVariantfvEXT = _link_function('glVariantfvEXT', None, [GLuint, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:6961
glVariantdvEXT = _link_function('glVariantdvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_shader')
# GL/glext.h:6962
glVariantubvEXT = _link_function('glVariantubvEXT', None, [GLuint, POINTER(GLubyte)], 'EXT_vertex_shader')
# GL/glext.h:6963
glVariantusvEXT = _link_function('glVariantusvEXT', None, [GLuint, POINTER(GLushort)], 'EXT_vertex_shader')
# GL/glext.h:6964
glVariantuivEXT = _link_function('glVariantuivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_vertex_shader')
# GL/glext.h:6965
glVariantPointerEXT = _link_function('glVariantPointerEXT', None, [GLuint, GLenum, GLuint, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:6966
glEnableVariantClientStateEXT = _link_function('glEnableVariantClientStateEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:6967
glDisableVariantClientStateEXT = _link_function('glDisableVariantClientStateEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:6968
glBindLightParameterEXT = _link_function('glBindLightParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6969
glBindMaterialParameterEXT = _link_function('glBindMaterialParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6970
glBindTexGenParameterEXT = _link_function('glBindTexGenParameterEXT', GLuint, [GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6971
glBindTextureUnitParameterEXT = _link_function('glBindTextureUnitParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6972
glBindParameterEXT = _link_function('glBindParameterEXT', GLuint, [GLenum], 'EXT_vertex_shader')
# GL/glext.h:6973
glIsVariantEnabledEXT = _link_function('glIsVariantEnabledEXT', GLboolean, [GLuint, GLenum], 'EXT_vertex_shader')
# GL/glext.h:6974
glGetVariantBooleanvEXT = _link_function('glGetVariantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:6975
glGetVariantIntegervEXT = _link_function('glGetVariantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:6976
glGetVariantFloatvEXT = _link_function('glGetVariantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:6977
glGetVariantPointervEXT = _link_function('glGetVariantPointervEXT', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'EXT_vertex_shader')
# GL/glext.h:6978
glGetInvariantBooleanvEXT = _link_function('glGetInvariantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:6979
glGetInvariantIntegervEXT = _link_function('glGetInvariantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:6980
glGetInvariantFloatvEXT = _link_function('glGetInvariantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:6981
glGetLocalConstantBooleanvEXT = _link_function('glGetLocalConstantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:6982
glGetLocalConstantIntegervEXT = _link_function('glGetLocalConstantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:6983
glGetLocalConstantFloatvEXT = _link_function('glGetLocalConstantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
PFNGLBEGINVERTEXSHADEREXTPROC = CFUNCTYPE(None) # GL/glext.h:6985
PFNGLENDVERTEXSHADEREXTPROC = CFUNCTYPE(None) # GL/glext.h:6986
PFNGLBINDVERTEXSHADEREXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6987
PFNGLGENVERTEXSHADERSEXTPROC = CFUNCTYPE(GLuint, GLuint) # GL/glext.h:6988
PFNGLDELETEVERTEXSHADEREXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6989
PFNGLSHADEROP1EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:6990
PFNGLSHADEROP2EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint) # GL/glext.h:6991
PFNGLSHADEROP3EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6992
PFNGLSWIZZLEEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6993
PFNGLWRITEMASKEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6994
PFNGLINSERTCOMPONENTEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:6995
PFNGLEXTRACTCOMPONENTEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:6996
PFNGLGENSYMBOLSEXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:6997
PFNGLSETINVARIANTEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid)) # GL/glext.h:6998
PFNGLSETLOCALCONSTANTEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid)) # GL/glext.h:6999
PFNGLVARIANTBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:7000
PFNGLVARIANTSVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:7001
PFNGLVARIANTIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7002
PFNGLVARIANTFVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:7003
PFNGLVARIANTDVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:7004
PFNGLVARIANTUBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:7005
PFNGLVARIANTUSVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:7006
PFNGLVARIANTUIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:7007
PFNGLVARIANTPOINTEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLvoid)) # GL/glext.h:7008
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7009
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7010
PFNGLBINDLIGHTPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:7011
PFNGLBINDMATERIALPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:7012
PFNGLBINDTEXGENPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum, GLenum) # GL/glext.h:7013
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:7014
PFNGLBINDPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum) # GL/glext.h:7015
PFNGLISVARIANTENABLEDEXTPROC = CFUNCTYPE(GLboolean, GLuint, GLenum) # GL/glext.h:7016
PFNGLGETVARIANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:7017
PFNGLGETVARIANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7018
PFNGLGETVARIANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7019
PFNGLGETVARIANTPOINTERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:7020
PFNGLGETINVARIANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:7021
PFNGLGETINVARIANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7022
PFNGLGETINVARIANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7023
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:7024
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7025
PFNGLGETLOCALCONSTANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7026
# ATI_vertex_streams (GL/glext.h:7029)
GL_ATI_vertex_streams = 1 # GL/glext.h:7030
# GL/glext.h:7032
glVertexStream1sATI = _link_function('glVertexStream1sATI', None, [GLenum, GLshort], 'ATI_vertex_streams')
# GL/glext.h:7033
glVertexStream1svATI = _link_function('glVertexStream1svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:7034
glVertexStream1iATI = _link_function('glVertexStream1iATI', None, [GLenum, GLint], 'ATI_vertex_streams')
# GL/glext.h:7035
glVertexStream1ivATI = _link_function('glVertexStream1ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:7036
glVertexStream1fATI = _link_function('glVertexStream1fATI', None, [GLenum, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:7037
glVertexStream1fvATI = _link_function('glVertexStream1fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:7038
glVertexStream1dATI = _link_function('glVertexStream1dATI', None, [GLenum, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:7039
glVertexStream1dvATI = _link_function('glVertexStream1dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:7040
glVertexStream2sATI = _link_function('glVertexStream2sATI', None, [GLenum, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:7041
glVertexStream2svATI = _link_function('glVertexStream2svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:7042
glVertexStream2iATI = _link_function('glVertexStream2iATI', None, [GLenum, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:7043
glVertexStream2ivATI = _link_function('glVertexStream2ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:7044
glVertexStream2fATI = _link_function('glVertexStream2fATI', None, [GLenum, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:7045
glVertexStream2fvATI = _link_function('glVertexStream2fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:7046
glVertexStream2dATI = _link_function('glVertexStream2dATI', None, [GLenum, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:7047
glVertexStream2dvATI = _link_function('glVertexStream2dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:7048
glVertexStream3sATI = _link_function('glVertexStream3sATI', None, [GLenum, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:7049
glVertexStream3svATI = _link_function('glVertexStream3svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:7050
glVertexStream3iATI = _link_function('glVertexStream3iATI', None, [GLenum, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:7051
glVertexStream3ivATI = _link_function('glVertexStream3ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:7052
glVertexStream3fATI = _link_function('glVertexStream3fATI', None, [GLenum, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:7053
glVertexStream3fvATI = _link_function('glVertexStream3fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:7054
glVertexStream3dATI = _link_function('glVertexStream3dATI', None, [GLenum, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:7055
glVertexStream3dvATI = _link_function('glVertexStream3dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:7056
glVertexStream4sATI = _link_function('glVertexStream4sATI', None, [GLenum, GLshort, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:7057
glVertexStream4svATI = _link_function('glVertexStream4svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:7058
glVertexStream4iATI = _link_function('glVertexStream4iATI', None, [GLenum, GLint, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:7059
glVertexStream4ivATI = _link_function('glVertexStream4ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:7060
glVertexStream4fATI = _link_function('glVertexStream4fATI', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:7061
glVertexStream4fvATI = _link_function('glVertexStream4fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:7062
glVertexStream4dATI = _link_function('glVertexStream4dATI', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:7063
glVertexStream4dvATI = _link_function('glVertexStream4dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:7064
glNormalStream3bATI = _link_function('glNormalStream3bATI', None, [GLenum, GLbyte, GLbyte, GLbyte], 'ATI_vertex_streams')
# GL/glext.h:7065
glNormalStream3bvATI = _link_function('glNormalStream3bvATI', None, [GLenum, POINTER(GLbyte)], 'ATI_vertex_streams')
# GL/glext.h:7066
glNormalStream3sATI = _link_function('glNormalStream3sATI', None, [GLenum, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:7067
glNormalStream3svATI = _link_function('glNormalStream3svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:7068
glNormalStream3iATI = _link_function('glNormalStream3iATI', None, [GLenum, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:7069
glNormalStream3ivATI = _link_function('glNormalStream3ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:7070
glNormalStream3fATI = _link_function('glNormalStream3fATI', None, [GLenum, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:7071
glNormalStream3fvATI = _link_function('glNormalStream3fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:7072
glNormalStream3dATI = _link_function('glNormalStream3dATI', None, [GLenum, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:7073
glNormalStream3dvATI = _link_function('glNormalStream3dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:7074
glClientActiveVertexStreamATI = _link_function('glClientActiveVertexStreamATI', None, [GLenum], 'ATI_vertex_streams')
# GL/glext.h:7075
glVertexBlendEnviATI = _link_function('glVertexBlendEnviATI', None, [GLenum, GLint], 'ATI_vertex_streams')
# GL/glext.h:7076
glVertexBlendEnvfATI = _link_function('glVertexBlendEnvfATI', None, [GLenum, GLfloat], 'ATI_vertex_streams')
PFNGLVERTEXSTREAM1SATIPROC = CFUNCTYPE(None, GLenum, GLshort) # GL/glext.h:7078
PFNGLVERTEXSTREAM1SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:7079
PFNGLVERTEXSTREAM1IATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7080
PFNGLVERTEXSTREAM1IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7081
PFNGLVERTEXSTREAM1FATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:7082
PFNGLVERTEXSTREAM1FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7083
PFNGLVERTEXSTREAM1DATIPROC = CFUNCTYPE(None, GLenum, GLdouble) # GL/glext.h:7084
PFNGLVERTEXSTREAM1DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:7085
PFNGLVERTEXSTREAM2SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort) # GL/glext.h:7086
PFNGLVERTEXSTREAM2SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:7087
PFNGLVERTEXSTREAM2IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint) # GL/glext.h:7088
PFNGLVERTEXSTREAM2IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7089
PFNGLVERTEXSTREAM2FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat) # GL/glext.h:7090
PFNGLVERTEXSTREAM2FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7091
PFNGLVERTEXSTREAM2DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble) # GL/glext.h:7092
PFNGLVERTEXSTREAM2DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:7093
PFNGLVERTEXSTREAM3SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # GL/glext.h:7094
PFNGLVERTEXSTREAM3SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:7095
PFNGLVERTEXSTREAM3IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # GL/glext.h:7096
PFNGLVERTEXSTREAM3IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7097
PFNGLVERTEXSTREAM3FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:7098
PFNGLVERTEXSTREAM3FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7099
PFNGLVERTEXSTREAM3DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:7100
PFNGLVERTEXSTREAM3DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:7101
PFNGLVERTEXSTREAM4SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:7102
PFNGLVERTEXSTREAM4SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:7103
PFNGLVERTEXSTREAM4IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint) # GL/glext.h:7104
PFNGLVERTEXSTREAM4IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7105
PFNGLVERTEXSTREAM4FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:7106
PFNGLVERTEXSTREAM4FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7107
PFNGLVERTEXSTREAM4DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:7108
PFNGLVERTEXSTREAM4DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:7109
PFNGLNORMALSTREAM3BATIPROC = CFUNCTYPE(None, GLenum, GLbyte, GLbyte, GLbyte) # GL/glext.h:7110
PFNGLNORMALSTREAM3BVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLbyte)) # GL/glext.h:7111
PFNGLNORMALSTREAM3SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # GL/glext.h:7112
PFNGLNORMALSTREAM3SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:7113
PFNGLNORMALSTREAM3IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # GL/glext.h:7114
PFNGLNORMALSTREAM3IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7115
PFNGLNORMALSTREAM3FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:7116
PFNGLNORMALSTREAM3FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7117
PFNGLNORMALSTREAM3DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:7118
PFNGLNORMALSTREAM3DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:7119
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7120
PFNGLVERTEXBLENDENVIATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7121
PFNGLVERTEXBLENDENVFATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:7122
# ATI_element_array (GL/glext.h:7125)
GL_ATI_element_array = 1 # GL/glext.h:7126
# GL/glext.h:7128
glElementPointerATI = _link_function('glElementPointerATI', None, [GLenum, POINTER(GLvoid)], 'ATI_element_array')
# GL/glext.h:7129
glDrawElementArrayATI = _link_function('glDrawElementArrayATI', None, [GLenum, GLsizei], 'ATI_element_array')
# GL/glext.h:7130
glDrawRangeElementArrayATI = _link_function('glDrawRangeElementArrayATI', None, [GLenum, GLuint, GLuint, GLsizei], 'ATI_element_array')
PFNGLELEMENTPOINTERATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:7132
PFNGLDRAWELEMENTARRAYATIPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:7133
PFNGLDRAWRANGEELEMENTARRAYATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei) # GL/glext.h:7134
# SUN_mesh_array (GL/glext.h:7137)
GL_SUN_mesh_array = 1 # GL/glext.h:7138
# GL/glext.h:7140
glDrawMeshArraysSUN = _link_function('glDrawMeshArraysSUN', None, [GLenum, GLint, GLsizei, GLsizei], 'SUN_mesh_array')
PFNGLDRAWMESHARRAYSSUNPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:7142
# SUN_slice_accum (GL/glext.h:7145)
GL_SUN_slice_accum = 1 # GL/glext.h:7146
# NV_multisample_filter_hint (GL/glext.h:7149)
GL_NV_multisample_filter_hint = 1 # GL/glext.h:7150
# NV_depth_clamp (GL/glext.h:7153)
GL_NV_depth_clamp = 1 # GL/glext.h:7154
# NV_occlusion_query (GL/glext.h:7157)
GL_NV_occlusion_query = 1 # GL/glext.h:7158
# GL/glext.h:7160
glGenOcclusionQueriesNV = _link_function('glGenOcclusionQueriesNV', None, [GLsizei, POINTER(GLuint)], 'NV_occlusion_query')
# GL/glext.h:7161
glDeleteOcclusionQueriesNV = _link_function('glDeleteOcclusionQueriesNV', None, [GLsizei, POINTER(GLuint)], 'NV_occlusion_query')
# GL/glext.h:7162
glIsOcclusionQueryNV = _link_function('glIsOcclusionQueryNV', GLboolean, [GLuint], 'NV_occlusion_query')
# GL/glext.h:7163
glBeginOcclusionQueryNV = _link_function('glBeginOcclusionQueryNV', None, [GLuint], 'NV_occlusion_query')
# GL/glext.h:7164
glEndOcclusionQueryNV = _link_function('glEndOcclusionQueryNV', None, [], 'NV_occlusion_query')
# GL/glext.h:7165
glGetOcclusionQueryivNV = _link_function('glGetOcclusionQueryivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_occlusion_query')
# GL/glext.h:7166
glGetOcclusionQueryuivNV = _link_function('glGetOcclusionQueryuivNV', None, [GLuint, GLenum, POINTER(GLuint)], 'NV_occlusion_query')
PFNGLGENOCCLUSIONQUERIESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7168
PFNGLDELETEOCCLUSIONQUERIESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7169
PFNGLISOCCLUSIONQUERYNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7170
PFNGLBEGINOCCLUSIONQUERYNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7171
PFNGLENDOCCLUSIONQUERYNVPROC = CFUNCTYPE(None) # GL/glext.h:7172
PFNGLGETOCCLUSIONQUERYIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7173
PFNGLGETOCCLUSIONQUERYUIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:7174
# NV_point_sprite (GL/glext.h:7177)
GL_NV_point_sprite = 1 # GL/glext.h:7178
# GL/glext.h:7180
glPointParameteriNV = _link_function('glPointParameteriNV', None, [GLenum, GLint], 'NV_point_sprite')
# GL/glext.h:7181
glPointParameterivNV = _link_function('glPointParameterivNV', None, [GLenum, POINTER(GLint)], 'NV_point_sprite')
PFNGLPOINTPARAMETERINVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7183
PFNGLPOINTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:7184
# NV_texture_shader3 (GL/glext.h:7187)
GL_NV_texture_shader3 = 1 # GL/glext.h:7188
# NV_vertex_program1_1 (GL/glext.h:7191)
GL_NV_vertex_program1_1 = 1 # GL/glext.h:7192
# EXT_shadow_funcs (GL/glext.h:7195)
GL_EXT_shadow_funcs = 1 # GL/glext.h:7196
# EXT_stencil_two_side (GL/glext.h:7199)
GL_EXT_stencil_two_side = 1 # GL/glext.h:7200
# GL/glext.h:7202
glActiveStencilFaceEXT = _link_function('glActiveStencilFaceEXT', None, [GLenum], 'EXT_stencil_two_side')
PFNGLACTIVESTENCILFACEEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7204
# ATI_text_fragment_shader (GL/glext.h:7207)
GL_ATI_text_fragment_shader = 1 # GL/glext.h:7208
# APPLE_client_storage (GL/glext.h:7211)
GL_APPLE_client_storage = 1 # GL/glext.h:7212
# APPLE_element_array (GL/glext.h:7215)
GL_APPLE_element_array = 1 # GL/glext.h:7216
# GL/glext.h:7218
glElementPointerAPPLE = _link_function('glElementPointerAPPLE', None, [GLenum, POINTER(GLvoid)], 'APPLE_element_array')
# GL/glext.h:7219
glDrawElementArrayAPPLE = _link_function('glDrawElementArrayAPPLE', None, [GLenum, GLint, GLsizei], 'APPLE_element_array')
# GL/glext.h:7220
glDrawRangeElementArrayAPPLE = _link_function('glDrawRangeElementArrayAPPLE', None, [GLenum, GLuint, GLuint, GLint, GLsizei], 'APPLE_element_array')
# GL/glext.h:7221
glMultiDrawElementArrayAPPLE = _link_function('glMultiDrawElementArrayAPPLE', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'APPLE_element_array')
# GL/glext.h:7222
glMultiDrawRangeElementArrayAPPLE = _link_function('glMultiDrawRangeElementArrayAPPLE', None, [GLenum, GLuint, GLuint, POINTER(GLint), POINTER(GLsizei), GLsizei], 'APPLE_element_array')
PFNGLELEMENTPOINTERAPPLEPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:7224
PFNGLDRAWELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei) # GL/glext.h:7225
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLint, GLsizei) # GL/glext.h:7226
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:7227
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:7228
# APPLE_fence (GL/glext.h:7231)
GL_APPLE_fence = 1 # GL/glext.h:7232
# GL/glext.h:7234
glGenFencesAPPLE = _link_function('glGenFencesAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_fence')
# GL/glext.h:7235
glDeleteFencesAPPLE = _link_function('glDeleteFencesAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_fence')
# GL/glext.h:7236
glSetFenceAPPLE = _link_function('glSetFenceAPPLE', None, [GLuint], 'APPLE_fence')
# GL/glext.h:7237
glIsFenceAPPLE = _link_function('glIsFenceAPPLE', GLboolean, [GLuint], 'APPLE_fence')
# GL/glext.h:7238
glTestFenceAPPLE = _link_function('glTestFenceAPPLE', GLboolean, [GLuint], 'APPLE_fence')
# GL/glext.h:7239
glFinishFenceAPPLE = _link_function('glFinishFenceAPPLE', None, [GLuint], 'APPLE_fence')
# GL/glext.h:7240
glTestObjectAPPLE = _link_function('glTestObjectAPPLE', GLboolean, [GLenum, GLuint], 'APPLE_fence')
# GL/glext.h:7241
glFinishObjectAPPLE = _link_function('glFinishObjectAPPLE', None, [GLenum, GLint], 'APPLE_fence')
PFNGLGENFENCESAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7243
PFNGLDELETEFENCESAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7244
PFNGLSETFENCEAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7245
PFNGLISFENCEAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7246
PFNGLTESTFENCEAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7247
PFNGLFINISHFENCEAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7248
PFNGLTESTOBJECTAPPLEPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:7249
PFNGLFINISHOBJECTAPPLEPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7250
# APPLE_vertex_array_object (GL/glext.h:7253)
GL_APPLE_vertex_array_object = 1 # GL/glext.h:7254
# GL/glext.h:7256
glBindVertexArrayAPPLE = _link_function('glBindVertexArrayAPPLE', None, [GLuint], 'APPLE_vertex_array_object')
# GL/glext.h:7257
glDeleteVertexArraysAPPLE = _link_function('glDeleteVertexArraysAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_vertex_array_object')
# GL/glext.h:7258
glGenVertexArraysAPPLE = _link_function('glGenVertexArraysAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_vertex_array_object')
# GL/glext.h:7259
glIsVertexArrayAPPLE = _link_function('glIsVertexArrayAPPLE', GLboolean, [GLuint], 'APPLE_vertex_array_object')
PFNGLBINDVERTEXARRAYAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7261
PFNGLDELETEVERTEXARRAYSAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7262
PFNGLGENVERTEXARRAYSAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7263
PFNGLISVERTEXARRAYAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7264
# APPLE_vertex_array_range (GL/glext.h:7267)
GL_APPLE_vertex_array_range = 1 # GL/glext.h:7268
# GL/glext.h:7270
glVertexArrayRangeAPPLE = _link_function('glVertexArrayRangeAPPLE', None, [GLsizei, POINTER(GLvoid)], 'APPLE_vertex_array_range')
# GL/glext.h:7271
glFlushVertexArrayRangeAPPLE = _link_function('glFlushVertexArrayRangeAPPLE', None, [GLsizei, POINTER(GLvoid)], 'APPLE_vertex_array_range')
# GL/glext.h:7272
glVertexArrayParameteriAPPLE = _link_function('glVertexArrayParameteriAPPLE', None, [GLenum, GLint], 'APPLE_vertex_array_range')
PFNGLVERTEXARRAYRANGEAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:7274
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:7275
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7276
# APPLE_ycbcr_422 (GL/glext.h:7279)
GL_APPLE_ycbcr_422 = 1 # GL/glext.h:7280
# S3_s3tc (GL/glext.h:7283)
GL_S3_s3tc = 1 # GL/glext.h:7284
# ATI_draw_buffers (GL/glext.h:7287)
GL_ATI_draw_buffers = 1 # GL/glext.h:7288
# GL/glext.h:7290
glDrawBuffersATI = _link_function('glDrawBuffersATI', None, [GLsizei, POINTER(GLenum)], 'ATI_draw_buffers')
PFNGLDRAWBUFFERSATIPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:7292
# ATI_pixel_format_float (GL/glext.h:7295)
GL_ATI_pixel_format_float = 1 # GL/glext.h:7296
# ATI_texture_env_combine3 (GL/glext.h:7302)
GL_ATI_texture_env_combine3 = 1 # GL/glext.h:7303
# ATI_texture_float (GL/glext.h:7306)
GL_ATI_texture_float = 1 # GL/glext.h:7307
# NV_float_buffer (GL/glext.h:7310)
GL_NV_float_buffer = 1 # GL/glext.h:7311
# NV_fragment_program (GL/glext.h:7314)
GL_NV_fragment_program = 1 # GL/glext.h:7315
# GL/glext.h:7318
glProgramNamedParameter4fNV = _link_function('glProgramNamedParameter4fNV', None, [GLuint, GLsizei, POINTER(GLubyte), GLfloat, GLfloat, GLfloat, GLfloat], 'NV_fragment_program')
# GL/glext.h:7319
glProgramNamedParameter4dNV = _link_function('glProgramNamedParameter4dNV', None, [GLuint, GLsizei, POINTER(GLubyte), GLdouble, GLdouble, GLdouble, GLdouble], 'NV_fragment_program')
# GL/glext.h:7320
glProgramNamedParameter4fvNV = _link_function('glProgramNamedParameter4fvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)], 'NV_fragment_program')
# GL/glext.h:7321
glProgramNamedParameter4dvNV = _link_function('glProgramNamedParameter4dvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)], 'NV_fragment_program')
# GL/glext.h:7322
glGetProgramNamedParameterfvNV = _link_function('glGetProgramNamedParameterfvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)], 'NV_fragment_program')
# GL/glext.h:7323
glGetProgramNamedParameterdvNV = _link_function('glGetProgramNamedParameterdvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)], 'NV_fragment_program')
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:7325
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:7326
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:7327
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)) # GL/glext.h:7328
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:7329
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)) # GL/glext.h:7330
# NV_half_float (GL/glext.h:7333)
GL_NV_half_float = 1 # GL/glext.h:7334
# GL/glext.h:7336
glVertex2hNV = _link_function('glVertex2hNV', None, [GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7337
glVertex2hvNV = _link_function('glVertex2hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7338
glVertex3hNV = _link_function('glVertex3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7339
glVertex3hvNV = _link_function('glVertex3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7340
glVertex4hNV = _link_function('glVertex4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7341
glVertex4hvNV = _link_function('glVertex4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7342
glNormal3hNV = _link_function('glNormal3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7343
glNormal3hvNV = _link_function('glNormal3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7344
glColor3hNV = _link_function('glColor3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7345
glColor3hvNV = _link_function('glColor3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7346
glColor4hNV = _link_function('glColor4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7347
glColor4hvNV = _link_function('glColor4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7348
glTexCoord1hNV = _link_function('glTexCoord1hNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:7349
glTexCoord1hvNV = _link_function('glTexCoord1hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7350
glTexCoord2hNV = _link_function('glTexCoord2hNV', None, [GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7351
glTexCoord2hvNV = _link_function('glTexCoord2hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7352
glTexCoord3hNV = _link_function('glTexCoord3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7353
glTexCoord3hvNV = _link_function('glTexCoord3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7354
glTexCoord4hNV = _link_function('glTexCoord4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7355
glTexCoord4hvNV = _link_function('glTexCoord4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7356
glMultiTexCoord1hNV = _link_function('glMultiTexCoord1hNV', None, [GLenum, GLhalfNV], 'NV_half_float')
# GL/glext.h:7357
glMultiTexCoord1hvNV = _link_function('glMultiTexCoord1hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7358
glMultiTexCoord2hNV = _link_function('glMultiTexCoord2hNV', None, [GLenum, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7359
glMultiTexCoord2hvNV = _link_function('glMultiTexCoord2hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7360
glMultiTexCoord3hNV = _link_function('glMultiTexCoord3hNV', None, [GLenum, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7361
glMultiTexCoord3hvNV = _link_function('glMultiTexCoord3hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7362
glMultiTexCoord4hNV = _link_function('glMultiTexCoord4hNV', None, [GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7363
glMultiTexCoord4hvNV = _link_function('glMultiTexCoord4hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7364
glFogCoordhNV = _link_function('glFogCoordhNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:7365
glFogCoordhvNV = _link_function('glFogCoordhvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7366
glSecondaryColor3hNV = _link_function('glSecondaryColor3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7367
glSecondaryColor3hvNV = _link_function('glSecondaryColor3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7368
glVertexWeighthNV = _link_function('glVertexWeighthNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:7369
glVertexWeighthvNV = _link_function('glVertexWeighthvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7370
glVertexAttrib1hNV = _link_function('glVertexAttrib1hNV', None, [GLuint, GLhalfNV], 'NV_half_float')
# GL/glext.h:7371
glVertexAttrib1hvNV = _link_function('glVertexAttrib1hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7372
glVertexAttrib2hNV = _link_function('glVertexAttrib2hNV', None, [GLuint, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7373
glVertexAttrib2hvNV = _link_function('glVertexAttrib2hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7374
glVertexAttrib3hNV = _link_function('glVertexAttrib3hNV', None, [GLuint, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7375
glVertexAttrib3hvNV = _link_function('glVertexAttrib3hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7376
glVertexAttrib4hNV = _link_function('glVertexAttrib4hNV', None, [GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:7377
glVertexAttrib4hvNV = _link_function('glVertexAttrib4hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7378
glVertexAttribs1hvNV = _link_function('glVertexAttribs1hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7379
glVertexAttribs2hvNV = _link_function('glVertexAttribs2hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7380
glVertexAttribs3hvNV = _link_function('glVertexAttribs3hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:7381
glVertexAttribs4hvNV = _link_function('glVertexAttribs4hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
PFNGLVERTEX2HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV) # GL/glext.h:7383
PFNGLVERTEX2HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7384
PFNGLVERTEX3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7385
PFNGLVERTEX3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7386
PFNGLVERTEX4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7387
PFNGLVERTEX4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7388
PFNGLNORMAL3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7389
PFNGLNORMAL3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7390
PFNGLCOLOR3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7391
PFNGLCOLOR3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7392
PFNGLCOLOR4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7393
PFNGLCOLOR4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7394
PFNGLTEXCOORD1HNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:7395
PFNGLTEXCOORD1HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7396
PFNGLTEXCOORD2HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV) # GL/glext.h:7397
PFNGLTEXCOORD2HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7398
PFNGLTEXCOORD3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7399
PFNGLTEXCOORD3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7400
PFNGLTEXCOORD4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7401
PFNGLTEXCOORD4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7402
PFNGLMULTITEXCOORD1HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV) # GL/glext.h:7403
PFNGLMULTITEXCOORD1HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:7404
PFNGLMULTITEXCOORD2HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV) # GL/glext.h:7405
PFNGLMULTITEXCOORD2HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:7406
PFNGLMULTITEXCOORD3HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7407
PFNGLMULTITEXCOORD3HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:7408
PFNGLMULTITEXCOORD4HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7409
PFNGLMULTITEXCOORD4HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:7410
PFNGLFOGCOORDHNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:7411
PFNGLFOGCOORDHVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7412
PFNGLSECONDARYCOLOR3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7413
PFNGLSECONDARYCOLOR3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7414
PFNGLVERTEXWEIGHTHNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:7415
PFNGLVERTEXWEIGHTHVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:7416
PFNGLVERTEXATTRIB1HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV) # GL/glext.h:7417
PFNGLVERTEXATTRIB1HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:7418
PFNGLVERTEXATTRIB2HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV) # GL/glext.h:7419
PFNGLVERTEXATTRIB2HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:7420
PFNGLVERTEXATTRIB3HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7421
PFNGLVERTEXATTRIB3HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:7422
PFNGLVERTEXATTRIB4HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:7423
PFNGLVERTEXATTRIB4HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:7424
PFNGLVERTEXATTRIBS1HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:7425
PFNGLVERTEXATTRIBS2HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:7426
PFNGLVERTEXATTRIBS3HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:7427
PFNGLVERTEXATTRIBS4HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:7428
# NV_pixel_data_range (GL/glext.h:7431)
GL_NV_pixel_data_range = 1 # GL/glext.h:7432
# GL/glext.h:7434
glPixelDataRangeNV = _link_function('glPixelDataRangeNV', None, [GLenum, GLsizei, POINTER(GLvoid)], 'NV_pixel_data_range')
# GL/glext.h:7435
glFlushPixelDataRangeNV = _link_function('glFlushPixelDataRangeNV', None, [GLenum], 'NV_pixel_data_range')
PFNGLPIXELDATARANGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7437
PFNGLFLUSHPIXELDATARANGENVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7438
# NV_primitive_restart (GL/glext.h:7441)
GL_NV_primitive_restart = 1 # GL/glext.h:7442
# GL/glext.h:7444
glPrimitiveRestartNV = _link_function('glPrimitiveRestartNV', None, [], 'NV_primitive_restart')
# GL/glext.h:7445
glPrimitiveRestartIndexNV = _link_function('glPrimitiveRestartIndexNV', None, [GLuint], 'NV_primitive_restart')
PFNGLPRIMITIVERESTARTNVPROC = CFUNCTYPE(None) # GL/glext.h:7447
PFNGLPRIMITIVERESTARTINDEXNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7448
# NV_texture_expand_normal (GL/glext.h:7451)
GL_NV_texture_expand_normal = 1 # GL/glext.h:7452
# NV_vertex_program2 (GL/glext.h:7455)
GL_NV_vertex_program2 = 1 # GL/glext.h:7456
# ATI_map_object_buffer (GL/glext.h:7459)
GL_ATI_map_object_buffer = 1 # GL/glext.h:7460
# GL/glext.h:7462
glMapObjectBufferATI = _link_function('glMapObjectBufferATI', POINTER(GLvoid), [GLuint], 'ATI_map_object_buffer')
# GL/glext.h:7463
glUnmapObjectBufferATI = _link_function('glUnmapObjectBufferATI', None, [GLuint], 'ATI_map_object_buffer')
PFNGLMAPOBJECTBUFFERATIPROC = CFUNCTYPE(POINTER(GLvoid), GLuint) # GL/glext.h:7465
PFNGLUNMAPOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7466
# ATI_separate_stencil (GL/glext.h:7469)
GL_ATI_separate_stencil = 1 # GL/glext.h:7470
# GL/glext.h:7472
glStencilOpSeparateATI = _link_function('glStencilOpSeparateATI', None, [GLenum, GLenum, GLenum, GLenum], 'ATI_separate_stencil')
# GL/glext.h:7473
glStencilFuncSeparateATI = _link_function('glStencilFuncSeparateATI', None, [GLenum, GLenum, GLint, GLuint], 'ATI_separate_stencil')
PFNGLSTENCILOPSEPARATEATIPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:7475
PFNGLSTENCILFUNCSEPARATEATIPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLuint) # GL/glext.h:7476
# ATI_vertex_attrib_array_object (GL/glext.h:7479)
GL_ATI_vertex_attrib_array_object = 1 # GL/glext.h:7480
# GL/glext.h:7482
glVertexAttribArrayObjectATI = _link_function('glVertexAttribArrayObjectATI', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint], 'ATI_vertex_attrib_array_object')
# GL/glext.h:7483
glGetVertexAttribArrayObjectfvATI = _link_function('glGetVertexAttribArrayObjectfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_attrib_array_object')
# GL/glext.h:7484
glGetVertexAttribArrayObjectivATI = _link_function('glGetVertexAttribArrayObjectivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_attrib_array_object')
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint) # GL/glext.h:7486
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7487
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7488
# OES_read_format (GL/glext.h:7491)
GL_OES_read_format = 1 # GL/glext.h:7492
# EXT_depth_bounds_test (GL/glext.h:7495)
GL_EXT_depth_bounds_test = 1 # GL/glext.h:7496
GLclampd = c_double # /usr/include/GL/gl.h:163
# GL/glext.h:7498
glDepthBoundsEXT = _link_function('glDepthBoundsEXT', None, [GLclampd, GLclampd], 'EXT_depth_bounds_test')
PFNGLDEPTHBOUNDSEXTPROC = CFUNCTYPE(None, GLclampd, GLclampd) # GL/glext.h:7500
# EXT_texture_mirror_clamp (GL/glext.h:7503)
GL_EXT_texture_mirror_clamp = 1 # GL/glext.h:7504
# EXT_blend_equation_separate (GL/glext.h:7507)
GL_EXT_blend_equation_separate = 1 # GL/glext.h:7508
# GL/glext.h:7510
glBlendEquationSeparateEXT = _link_function('glBlendEquationSeparateEXT', None, [GLenum, GLenum], 'EXT_blend_equation_separate')
PFNGLBLENDEQUATIONSEPARATEEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:7512
# MESA_pack_invert (GL/glext.h:7515)
GL_MESA_pack_invert = 1 # GL/glext.h:7516
# MESA_ycbcr_texture (GL/glext.h:7519)
GL_MESA_ycbcr_texture = 1 # GL/glext.h:7520
# EXT_pixel_buffer_object (GL/glext.h:7523)
GL_EXT_pixel_buffer_object = 1 # GL/glext.h:7524
# NV_fragment_program_option (GL/glext.h:7527)
GL_NV_fragment_program_option = 1 # GL/glext.h:7528
# NV_fragment_program2 (GL/glext.h:7531)
GL_NV_fragment_program2 = 1 # GL/glext.h:7532
# NV_vertex_program2_option (GL/glext.h:7535)
GL_NV_vertex_program2_option = 1 # GL/glext.h:7536
# NV_vertex_program3 (GL/glext.h:7539)
GL_NV_vertex_program3 = 1 # GL/glext.h:7540
# EXT_framebuffer_object (GL/glext.h:7543)
GL_EXT_framebuffer_object = 1 # GL/glext.h:7544
# GL/glext.h:7546
glIsRenderbufferEXT = _link_function('glIsRenderbufferEXT', GLboolean, [GLuint], 'EXT_framebuffer_object')
# GL/glext.h:7547
glBindRenderbufferEXT = _link_function('glBindRenderbufferEXT', None, [GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:7548
glDeleteRenderbuffersEXT = _link_function('glDeleteRenderbuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:7549
glGenRenderbuffersEXT = _link_function('glGenRenderbuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:7550
glRenderbufferStorageEXT = _link_function('glRenderbufferStorageEXT', None, [GLenum, GLenum, GLsizei, GLsizei], 'EXT_framebuffer_object')
# GL/glext.h:7551
glGetRenderbufferParameterivEXT = _link_function('glGetRenderbufferParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_framebuffer_object')
# GL/glext.h:7552
glIsFramebufferEXT = _link_function('glIsFramebufferEXT', GLboolean, [GLuint], 'EXT_framebuffer_object')
# GL/glext.h:7553
glBindFramebufferEXT = _link_function('glBindFramebufferEXT', None, [GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:7554
glDeleteFramebuffersEXT = _link_function('glDeleteFramebuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:7555
glGenFramebuffersEXT = _link_function('glGenFramebuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:7556
glCheckFramebufferStatusEXT = _link_function('glCheckFramebufferStatusEXT', GLenum, [GLenum], 'EXT_framebuffer_object')
# GL/glext.h:7557
glFramebufferTexture1DEXT = _link_function('glFramebufferTexture1DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:7558
glFramebufferTexture2DEXT = _link_function('glFramebufferTexture2DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:7559
glFramebufferTexture3DEXT = _link_function('glFramebufferTexture3DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:7560
glFramebufferRenderbufferEXT = _link_function('glFramebufferRenderbufferEXT', None, [GLenum, GLenum, GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:7561
glGetFramebufferAttachmentParameterivEXT = _link_function('glGetFramebufferAttachmentParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_framebuffer_object')
# GL/glext.h:7562
glGenerateMipmapEXT = _link_function('glGenerateMipmapEXT', None, [GLenum], 'EXT_framebuffer_object')
PFNGLISRENDERBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7564
PFNGLBINDRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7565
PFNGLDELETERENDERBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7566
PFNGLGENRENDERBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7567
PFNGLRENDERBUFFERSTORAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei) # GL/glext.h:7568
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7569
PFNGLISFRAMEBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7570
PFNGLBINDFRAMEBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7571
PFNGLDELETEFRAMEBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7572
PFNGLGENFRAMEBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7573
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = CFUNCTYPE(GLenum, GLenum) # GL/glext.h:7574
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:7575
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:7576
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:7577
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:7578
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7579
PFNGLGENERATEMIPMAPEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7580
# GREMEDY_string_marker (GL/glext.h:7583)
GL_GREMEDY_string_marker = 1 # GL/glext.h:7584
# GL/glext.h:7586
glStringMarkerGREMEDY = _link_function('glStringMarkerGREMEDY', None, [GLsizei, POINTER(GLvoid)], 'GREMEDY_string_marker')
PFNGLSTRINGMARKERGREMEDYPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:7588
# EXT_Cg_shader (GL/glext.h:7591)
GL_EXT_Cg_shader = 1 # GL/glext.h:7592
# EXT_timer_query (GL/glext.h:7595)
GL_EXT_timer_query = 1 # GL/glext.h:7596
# GL/glext.h:7598
glGetQueryObjecti64vEXT = _link_function('glGetQueryObjecti64vEXT', None, [GLuint, GLenum, POINTER(GLint64EXT)], 'EXT_timer_query')
# GL/glext.h:7599
glGetQueryObjectui64vEXT = _link_function('glGetQueryObjectui64vEXT', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'EXT_timer_query')
PFNGLGETQUERYOBJECTI64VEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64EXT)) # GL/glext.h:7601
PFNGLGETQUERYOBJECTUI64VEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:7602
# EXT_texture_buffer_object (GL/glext.h:7605)
GL_EXT_texture_buffer_object = 1 # GL/glext.h:7606
# GL/glext.h:7608
glTexBufferEXT = _link_function('glTexBufferEXT', None, [GLenum, GLenum, GLuint], 'EXT_texture_buffer_object')
PFNGLTEXBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7610
# NV_transform_feedback (GL/glext.h:7613)
GL_NV_transform_feedback = 1 # GL/glext.h:7614
# GL/glext.h:7616
glBeginTransformFeedbackNV = _link_function('glBeginTransformFeedbackNV', None, [GLenum], 'NV_transform_feedback')
# GL/glext.h:7617
glEndTransformFeedbackNV = _link_function('glEndTransformFeedbackNV', None, [], 'NV_transform_feedback')
# GL/glext.h:7618
glTransformFeedbackAttribsNV = _link_function('glTransformFeedbackAttribsNV', None, [GLuint, POINTER(GLint), GLenum], 'NV_transform_feedback')
# GL/glext.h:7619
glBindBufferRangeNV = _link_function('glBindBufferRangeNV', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'NV_transform_feedback')
# GL/glext.h:7620
glBindBufferOffsetNV = _link_function('glBindBufferOffsetNV', None, [GLenum, GLuint, GLuint, GLintptr], 'NV_transform_feedback')
# GL/glext.h:7621
glBindBufferBaseNV = _link_function('glBindBufferBaseNV', None, [GLenum, GLuint, GLuint], 'NV_transform_feedback')
# GL/glext.h:7622
glTransformFeedbackVaryingsNV = _link_function('glTransformFeedbackVaryingsNV', None, [GLuint, GLsizei, POINTER(GLint), GLenum], 'NV_transform_feedback')
# GL/glext.h:7623
glActiveVaryingNV = _link_function('glActiveVaryingNV', None, [GLuint, POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:7624
glGetVaryingLocationNV = _link_function('glGetVaryingLocationNV', GLint, [GLuint, POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:7625
glGetActiveVaryingNV = _link_function('glGetActiveVaryingNV', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:7626
glGetTransformFeedbackVaryingNV = _link_function('glGetTransformFeedbackVaryingNV', None, [GLuint, GLuint, POINTER(GLint)], 'NV_transform_feedback')
PFNGLBEGINTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7628
PFNGLENDTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:7629
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint), GLenum) # GL/glext.h:7630
PFNGLBINDBUFFERRANGENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:7631
PFNGLBINDBUFFEROFFSETNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr) # GL/glext.h:7632
PFNGLBINDBUFFERBASENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:7633
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLint), GLenum) # GL/glext.h:7634
PFNGLACTIVEVARYINGNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLchar)) # GL/glext.h:7635
PFNGLGETVARYINGLOCATIONNVPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:7636
PFNGLGETACTIVEVARYINGNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:7637
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLint)) # GL/glext.h:7638
# NV_depth_buffer_float (GL/glext.h:7642)
GL_NV_depth_buffer_float = 1 # GL/glext.h:7643
# GL/glext.h:7645
glDepthRangedNV = _link_function('glDepthRangedNV', None, [GLdouble, GLdouble], 'NV_depth_buffer_float')
# GL/glext.h:7646
glClearDepthdNV = _link_function('glClearDepthdNV', None, [GLdouble], 'NV_depth_buffer_float')
# GL/glext.h:7647
glDepthBoundsdNV = _link_function('glDepthBoundsdNV', None, [GLdouble, GLdouble], 'NV_depth_buffer_float')
PFNGLDEPTHRANGEDNVPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:7649
PFNGLCLEARDEPTHDNVPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:7650
PFNGLDEPTHBOUNDSDNVPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:7651
# EXT_texture_compression_latc (GL/glext.h:7654)
GL_EXT_texture_compression_latc = 1 # GL/glext.h:7655
# EXT_framebuffer_sRGB (GL/glext.h:7658)
GL_EXT_framebuffer_sRGB = 1 # GL/glext.h:7659
# EXT_texture_shared_exponent (GL/glext.h:7662)
GL_EXT_texture_shared_exponent = 1 # GL/glext.h:7663
# EXT_packed_float (GL/glext.h:7666)
GL_EXT_packed_float = 1 # GL/glext.h:7667
# EXT_texture_array (GL/glext.h:7670)
GL_EXT_texture_array = 1 # GL/glext.h:7671
# EXT_draw_buffers2 (GL/glext.h:7674)
GL_EXT_draw_buffers2 = 1 # GL/glext.h:7675
# GL/glext.h:7677
glColorMaskIndexedEXT = _link_function('glColorMaskIndexedEXT', None, [GLuint, GLboolean, GLboolean, GLboolean, GLboolean], 'EXT_draw_buffers2')
# GL/glext.h:7678
glGetBooleanIndexedvEXT = _link_function('glGetBooleanIndexedvEXT', None, [GLenum, GLuint, POINTER(GLboolean)], 'EXT_draw_buffers2')
# GL/glext.h:7679
glGetIntegerIndexedvEXT = _link_function('glGetIntegerIndexedvEXT', None, [GLenum, GLuint, POINTER(GLint)], 'EXT_draw_buffers2')
# GL/glext.h:7680
glEnableIndexedEXT = _link_function('glEnableIndexedEXT', None, [GLenum, GLuint], 'EXT_draw_buffers2')
# GL/glext.h:7681
glDisableIndexedEXT = _link_function('glDisableIndexedEXT', None, [GLenum, GLuint], 'EXT_draw_buffers2')
# GL/glext.h:7682
glIsEnabledIndexedEXT = _link_function('glIsEnabledIndexedEXT', GLboolean, [GLenum, GLuint], 'EXT_draw_buffers2')
PFNGLCOLORMASKINDEXEDEXTPROC = CFUNCTYPE(None, GLuint, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:7684
PFNGLGETBOOLEANINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLboolean)) # GL/glext.h:7685
PFNGLGETINTEGERINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:7686
PFNGLENABLEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7687
PFNGLDISABLEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7688
PFNGLISENABLEDINDEXEDEXTPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:7689
# EXT_texture_integer (GL/glext.h:7692)
GL_EXT_texture_integer = 1 # GL/glext.h:7693
# GL/glext.h:7695
glTexParameterIivEXT = _link_function('glTexParameterIivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_texture_integer')
# GL/glext.h:7696
glTexParameterIuivEXT = _link_function('glTexParameterIuivEXT', None, [GLenum, GLenum, POINTER(GLuint)], 'EXT_texture_integer')
# GL/glext.h:7697
glGetTexParameterIivEXT = _link_function('glGetTexParameterIivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_texture_integer')
# GL/glext.h:7698
glGetTexParameterIuivEXT = _link_function('glGetTexParameterIuivEXT', None, [GLenum, GLenum, POINTER(GLuint)], 'EXT_texture_integer')
# GL/glext.h:7699
glClearColorIiEXT = _link_function('glClearColorIiEXT', None, [GLint, GLint, GLint, GLint], 'EXT_texture_integer')
# GL/glext.h:7700
glClearColorIuiEXT = _link_function('glClearColorIuiEXT', None, [GLuint, GLuint, GLuint, GLuint], 'EXT_texture_integer')
PFNGLTEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7702
PFNGLTEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7703
PFNGLGETTEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7704
PFNGLGETTEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7705
PFNGLCLEARCOLORIIEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:7706
PFNGLCLEARCOLORIUIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7707
# EXT_bindable_uniform (GL/glext.h:7710)
GL_EXT_bindable_uniform = 1 # GL/glext.h:7711
# GL/glext.h:7713
glUniformBufferEXT = _link_function('glUniformBufferEXT', None, [GLuint, GLint, GLuint], 'EXT_bindable_uniform')
# GL/glext.h:7714
glGetUniformBufferSizeEXT = _link_function('glGetUniformBufferSizeEXT', GLint, [GLuint, GLint], 'EXT_bindable_uniform')
# GL/glext.h:7715
glGetUniformOffsetEXT = _link_function('glGetUniformOffsetEXT', GLintptr, [GLuint, GLint], 'EXT_bindable_uniform')
PFNGLUNIFORMBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:7717
PFNGLGETUNIFORMBUFFERSIZEEXTPROC = CFUNCTYPE(GLint, GLuint, GLint) # GL/glext.h:7718
PFNGLGETUNIFORMOFFSETEXTPROC = CFUNCTYPE(GLintptr, GLuint, GLint) # GL/glext.h:7719
# EXT_gpu_shader4 (GL/glext.h:7722)
GL_EXT_gpu_shader4 = 1 # GL/glext.h:7723
# GL/glext.h:7725
glGetUniformuivEXT = _link_function('glGetUniformuivEXT', None, [GLuint, GLint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7726
glBindFragDataLocationEXT = _link_function('glBindFragDataLocationEXT', None, [GLuint, GLuint, POINTER(GLchar)], 'EXT_gpu_shader4')
# GL/glext.h:7727
glGetFragDataLocationEXT = _link_function('glGetFragDataLocationEXT', GLint, [GLuint, POINTER(GLchar)], 'EXT_gpu_shader4')
# GL/glext.h:7728
glUniform1uiEXT = _link_function('glUniform1uiEXT', None, [GLint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7729
glUniform2uiEXT = _link_function('glUniform2uiEXT', None, [GLint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7730
glUniform3uiEXT = _link_function('glUniform3uiEXT', None, [GLint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7731
glUniform4uiEXT = _link_function('glUniform4uiEXT', None, [GLint, GLuint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7732
glUniform1uivEXT = _link_function('glUniform1uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7733
glUniform2uivEXT = _link_function('glUniform2uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7734
glUniform3uivEXT = _link_function('glUniform3uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7735
glUniform4uivEXT = _link_function('glUniform4uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7736
glVertexAttribI1iEXT = _link_function('glVertexAttribI1iEXT', None, [GLuint, GLint], 'EXT_gpu_shader4')
# GL/glext.h:7737
glVertexAttribI2iEXT = _link_function('glVertexAttribI2iEXT', None, [GLuint, GLint, GLint], 'EXT_gpu_shader4')
# GL/glext.h:7738
glVertexAttribI3iEXT = _link_function('glVertexAttribI3iEXT', None, [GLuint, GLint, GLint, GLint], 'EXT_gpu_shader4')
# GL/glext.h:7739
glVertexAttribI4iEXT = _link_function('glVertexAttribI4iEXT', None, [GLuint, GLint, GLint, GLint, GLint], 'EXT_gpu_shader4')
# GL/glext.h:7740
glVertexAttribI1uiEXT = _link_function('glVertexAttribI1uiEXT', None, [GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7741
glVertexAttribI2uiEXT = _link_function('glVertexAttribI2uiEXT', None, [GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7742
glVertexAttribI3uiEXT = _link_function('glVertexAttribI3uiEXT', None, [GLuint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7743
glVertexAttribI4uiEXT = _link_function('glVertexAttribI4uiEXT', None, [GLuint, GLuint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:7744
glVertexAttribI1ivEXT = _link_function('glVertexAttribI1ivEXT', None, [GLuint, POINTER(GLint)], 'EXT_gpu_shader4')
# GL/glext.h:7745
glVertexAttribI2ivEXT = _link_function('glVertexAttribI2ivEXT', None, [GLuint, POINTER(GLint)], 'EXT_gpu_shader4')
# GL/glext.h:7746
glVertexAttribI3ivEXT = _link_function('glVertexAttribI3ivEXT', None, [GLuint, POINTER(GLint)], 'EXT_gpu_shader4')
# GL/glext.h:7747
glVertexAttribI4ivEXT = _link_function('glVertexAttribI4ivEXT', None, [GLuint, POINTER(GLint)], 'EXT_gpu_shader4')
# GL/glext.h:7748
glVertexAttribI1uivEXT = _link_function('glVertexAttribI1uivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7749
glVertexAttribI2uivEXT = _link_function('glVertexAttribI2uivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7750
glVertexAttribI3uivEXT = _link_function('glVertexAttribI3uivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7751
glVertexAttribI4uivEXT = _link_function('glVertexAttribI4uivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:7752
glVertexAttribI4bvEXT = _link_function('glVertexAttribI4bvEXT', None, [GLuint, POINTER(GLbyte)], 'EXT_gpu_shader4')
# GL/glext.h:7753
glVertexAttribI4svEXT = _link_function('glVertexAttribI4svEXT', None, [GLuint, POINTER(GLshort)], 'EXT_gpu_shader4')
# GL/glext.h:7754
glVertexAttribI4ubvEXT = _link_function('glVertexAttribI4ubvEXT', None, [GLuint, POINTER(GLubyte)], 'EXT_gpu_shader4')
# GL/glext.h:7755
glVertexAttribI4usvEXT = _link_function('glVertexAttribI4usvEXT', None, [GLuint, POINTER(GLushort)], 'EXT_gpu_shader4')
# GL/glext.h:7756
glVertexAttribIPointerEXT = _link_function('glVertexAttribIPointerEXT', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_gpu_shader4')
# GL/glext.h:7757
glGetVertexAttribIivEXT = _link_function('glGetVertexAttribIivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_gpu_shader4')
# GL/glext.h:7758
glGetVertexAttribIuivEXT = _link_function('glGetVertexAttribIuivEXT', None, [GLuint, GLenum, POINTER(GLuint)], 'EXT_gpu_shader4')
PFNGLGETUNIFORMUIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint)) # GL/glext.h:7760
PFNGLBINDFRAGDATALOCATIONEXTPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:7761
PFNGLGETFRAGDATALOCATIONEXTPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:7762
PFNGLUNIFORM1UIEXTPROC = CFUNCTYPE(None, GLint, GLuint) # GL/glext.h:7763
PFNGLUNIFORM2UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint) # GL/glext.h:7764
PFNGLUNIFORM3UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint) # GL/glext.h:7765
PFNGLUNIFORM4UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7766
PFNGLUNIFORM1UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7767
PFNGLUNIFORM2UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7768
PFNGLUNIFORM3UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7769
PFNGLUNIFORM4UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7770
PFNGLVERTEXATTRIBI1IEXTPROC = CFUNCTYPE(None, GLuint, GLint) # GL/glext.h:7771
PFNGLVERTEXATTRIBI2IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:7772
PFNGLVERTEXATTRIBI3IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:7773
PFNGLVERTEXATTRIBI4IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:7774
PFNGLVERTEXATTRIBI1UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:7775
PFNGLVERTEXATTRIBI2UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:7776
PFNGLVERTEXATTRIBI3UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7777
PFNGLVERTEXATTRIBI4UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7778
PFNGLVERTEXATTRIBI1IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7779
PFNGLVERTEXATTRIBI2IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7780
PFNGLVERTEXATTRIBI3IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7781
PFNGLVERTEXATTRIBI4IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7782
PFNGLVERTEXATTRIBI1UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:7783
PFNGLVERTEXATTRIBI2UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:7784
PFNGLVERTEXATTRIBI3UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:7785
PFNGLVERTEXATTRIBI4UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:7786
PFNGLVERTEXATTRIBI4BVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:7787
PFNGLVERTEXATTRIBI4SVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:7788
PFNGLVERTEXATTRIBI4UBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:7789
PFNGLVERTEXATTRIBI4USVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:7790
PFNGLVERTEXATTRIBIPOINTEREXTPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7791
PFNGLGETVERTEXATTRIBIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7792
PFNGLGETVERTEXATTRIBIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:7793
# EXT_geometry_shader4 (GL/glext.h:7797)
GL_EXT_geometry_shader4 = 1 # GL/glext.h:7798
# GL/glext.h:7800
glProgramParameteriEXT = _link_function('glProgramParameteriEXT', None, [GLuint, GLenum, GLint], 'EXT_geometry_shader4')
# GL/glext.h:7801
glFramebufferTextureEXT = _link_function('glFramebufferTextureEXT', None, [GLenum, GLenum, GLuint, GLint], 'EXT_geometry_shader4')
# GL/glext.h:7802
glFramebufferTextureLayerEXT = _link_function('glFramebufferTextureLayerEXT', None, [GLenum, GLenum, GLuint, GLint, GLint], 'EXT_geometry_shader4')
# GL/glext.h:7803
glFramebufferTextureFaceEXT = _link_function('glFramebufferTextureFaceEXT', None, [GLenum, GLenum, GLuint, GLint, GLenum], 'EXT_geometry_shader4')
PFNGLPROGRAMPARAMETERIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:7805
PFNGLFRAMEBUFFERTEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint) # GL/glext.h:7806
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:7807
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLenum) # GL/glext.h:7808
# NV_geometry_program4 (GL/glext.h:7811)
GL_NV_geometry_program4 = 1 # GL/glext.h:7812
# GL/glext.h:7814
glProgramVertexLimitNV = _link_function('glProgramVertexLimitNV', None, [GLenum, GLint], 'NV_geometry_program4')
PFNGLPROGRAMVERTEXLIMITNVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7816
# NV_gpu_program4 (GL/glext.h:7819)
GL_NV_gpu_program4 = 1 # GL/glext.h:7820
# GL/glext.h:7822
glProgramLocalParameterI4iNV = _link_function('glProgramLocalParameterI4iNV', None, [GLenum, GLuint, GLint, GLint, GLint, GLint], 'NV_gpu_program4')
# GL/glext.h:7823
glProgramLocalParameterI4ivNV = _link_function('glProgramLocalParameterI4ivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7824
glProgramLocalParametersI4ivNV = _link_function('glProgramLocalParametersI4ivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7825
glProgramLocalParameterI4uiNV = _link_function('glProgramLocalParameterI4uiNV', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'NV_gpu_program4')
# GL/glext.h:7826
glProgramLocalParameterI4uivNV = _link_function('glProgramLocalParameterI4uivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:7827
glProgramLocalParametersI4uivNV = _link_function('glProgramLocalParametersI4uivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:7828
glProgramEnvParameterI4iNV = _link_function('glProgramEnvParameterI4iNV', None, [GLenum, GLuint, GLint, GLint, GLint, GLint], 'NV_gpu_program4')
# GL/glext.h:7829
glProgramEnvParameterI4ivNV = _link_function('glProgramEnvParameterI4ivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7830
glProgramEnvParametersI4ivNV = _link_function('glProgramEnvParametersI4ivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7831
glProgramEnvParameterI4uiNV = _link_function('glProgramEnvParameterI4uiNV', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'NV_gpu_program4')
# GL/glext.h:7832
glProgramEnvParameterI4uivNV = _link_function('glProgramEnvParameterI4uivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:7833
glProgramEnvParametersI4uivNV = _link_function('glProgramEnvParametersI4uivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:7834
glGetProgramLocalParameterIivNV = _link_function('glGetProgramLocalParameterIivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7835
glGetProgramLocalParameterIuivNV = _link_function('glGetProgramLocalParameterIuivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:7836
glGetProgramEnvParameterIivNV = _link_function('glGetProgramEnvParameterIivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:7837
glGetProgramEnvParameterIuivNV = _link_function('glGetProgramEnvParameterIuivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
PFNGLPROGRAMLOCALPARAMETERI4INVPROC = CFUNCTYPE(None, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:7839
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:7840
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:7841
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7842
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:7843
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:7844
PFNGLPROGRAMENVPARAMETERI4INVPROC = CFUNCTYPE(None, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:7845
PFNGLPROGRAMENVPARAMETERI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:7846
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:7847
PFNGLPROGRAMENVPARAMETERI4UINVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7848
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:7849
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:7850
PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:7851
PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:7852
PFNGLGETPROGRAMENVPARAMETERIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:7853
PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:7854
# NV_parameter_buffer_object (GL/glext.h:7857)
GL_NV_parameter_buffer_object = 1 # GL/glext.h:7858
# GL/glext.h:7860
glProgramBufferParametersfvNV = _link_function('glProgramBufferParametersfvNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLfloat)], 'NV_parameter_buffer_object')
# GL/glext.h:7861
glProgramBufferParametersIivNV = _link_function('glProgramBufferParametersIivNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLint)], 'NV_parameter_buffer_object')
# GL/glext.h:7862
glProgramBufferParametersIuivNV = _link_function('glProgramBufferParametersIuivNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLuint)], 'NV_parameter_buffer_object')
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7864
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:7865
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:7866
# EXT_framebuffer_multisample (GL/glext.h:7869)
GL_EXT_framebuffer_multisample = 1 # GL/glext.h:7870
# GL/glext.h:7872
glRenderbufferStorageMultisampleEXT = _link_function('glRenderbufferStorageMultisampleEXT', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_framebuffer_multisample')
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:7874
# NV_framebuffer_multisample_coverage (GL/glext.h:7877)
GL_NV_framebuffer_multisample_coverage = 1 # GL/glext.h:7878
# GL/glext.h:7880
glRenderbufferStorageMultisampleCoverageNV = _link_function('glRenderbufferStorageMultisampleCoverageNV', None, [GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei], 'NV_framebuffer_multisample_coverage')
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:7882
# EXT_framebuffer_blit (GL/glext.h:7885)
GL_EXT_framebuffer_blit = 1 # GL/glext.h:7886
# GL/glext.h:7888
glBlitFramebufferEXT = _link_function('glBlitFramebufferEXT', None, [GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], 'EXT_framebuffer_blit')
PFNGLBLITFRAMEBUFFEREXTPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) # GL/glext.h:7890
# EXT_draw_instanced (GL/glext.h:7893)
GL_EXT_draw_instanced = 1 # GL/glext.h:7894
# GL/glext.h:7896
glDrawArraysInstancedEXT = _link_function('glDrawArraysInstancedEXT', None, [GLenum, GLint, GLsizei, GLsizei], 'EXT_draw_instanced')
# GL/glext.h:7897
glDrawElementsInstancedEXT = _link_function('glDrawElementsInstancedEXT', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei], 'EXT_draw_instanced')
PFNGLDRAWARRAYSINSTANCEDEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:7899
PFNGLDRAWELEMENTSINSTANCEDEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:7900
# EXT_texture_compression_rgtc (GL/glext.h:7903)
GL_EXT_texture_compression_rgtc = 1 # GL/glext.h:7904
# NV_present_video (GL/glext.h:7907)
GL_NV_present_video = 1 # GL/glext.h:7908
# GL/glext.h:7910
glPresentFrameKeyedNV = _link_function('glPresentFrameKeyedNV', None, [GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint], 'NV_present_video')
# GL/glext.h:7917
glPresentFrameDualFillNV = _link_function('glPresentFrameDualFillNV', None, [GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint], 'NV_present_video')
# GL/glext.h:7926
glGetVideoivNV = _link_function('glGetVideoivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_present_video')
# GL/glext.h:7927
glGetVideouivNV = _link_function('glGetVideouivNV', None, [GLuint, GLenum, POINTER(GLuint)], 'NV_present_video')
# GL/glext.h:7928
glGetVideoi64vNV = _link_function('glGetVideoi64vNV', None, [GLuint, GLenum, POINTER(GLint64EXT)], 'NV_present_video')
# GL/glext.h:7929
glGetVideoui64vNV = _link_function('glGetVideoui64vNV', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'NV_present_video')
PFNGLPRESENTFRAMEKEYEDNVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint) # GL/glext.h:7931
PFNGLPRESENTFRAMEDUALFILLNVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint) # GL/glext.h:7938
PFNGLGETVIDEOIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7947
PFNGLGETVIDEOUIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:7948
PFNGLGETVIDEOI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64EXT)) # GL/glext.h:7949
PFNGLGETVIDEOUI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:7950
# NV_conditional_render (GL/glext.h:7953)
GL_NV_conditional_render = 1 # GL/glext.h:7954
# GL/glext.h:7956
glBeginConditionalRenderNV = _link_function('glBeginConditionalRenderNV', None, [GLuint, GLenum], 'NV_conditional_render')
# GL/glext.h:7957
glEndConditionalRenderNV = _link_function('glEndConditionalRenderNV', None, [], 'NV_conditional_render')
PFNGLBEGINCONDITIONALRENDERNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:7959
PFNGLENDCONDITIONALRENDERNVPROC = CFUNCTYPE(None) # GL/glext.h:7960
# EXT_transform_feedback (GL/glext.h:7963)
GL_EXT_transform_feedback = 1 # GL/glext.h:7964
# GL/glext.h:7966
glBeginTransformFeedbackEXT = _link_function('glBeginTransformFeedbackEXT', None, [GLenum], 'EXT_transform_feedback')
# GL/glext.h:7967
glEndTransformFeedbackEXT = _link_function('glEndTransformFeedbackEXT', None, [], 'EXT_transform_feedback')
# GL/glext.h:7968
glBindBufferRangeEXT = _link_function('glBindBufferRangeEXT', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'EXT_transform_feedback')
# GL/glext.h:7969
glBindBufferOffsetEXT = _link_function('glBindBufferOffsetEXT', None, [GLenum, GLuint, GLuint, GLintptr], 'EXT_transform_feedback')
# GL/glext.h:7970
glBindBufferBaseEXT = _link_function('glBindBufferBaseEXT', None, [GLenum, GLuint, GLuint], 'EXT_transform_feedback')
# GL/glext.h:7971
glTransformFeedbackVaryingsEXT = _link_function('glTransformFeedbackVaryingsEXT', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum], 'EXT_transform_feedback')
# GL/glext.h:7972
glGetTransformFeedbackVaryingEXT = _link_function('glGetTransformFeedbackVaryingEXT', None, [GLuint, GLuint, POINTER(GLint)], 'EXT_transform_feedback')
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7974
PFNGLENDTRANSFORMFEEDBACKEXTPROC = CFUNCTYPE(None) # GL/glext.h:7975
PFNGLBINDBUFFERRANGEEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:7976
PFNGLBINDBUFFEROFFSETEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr) # GL/glext.h:7977
PFNGLBINDBUFFERBASEEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:7978
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLint), GLenum) # GL/glext.h:7979
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLint)) # GL/glext.h:7980
# EXT_direct_state_access (GL/glext.h:7983)
GL_EXT_direct_state_access = 1 # GL/glext.h:7984
# GL/glext.h:7986
glClientAttribDefaultEXT = _link_function('glClientAttribDefaultEXT', None, [GLbitfield], 'EXT_direct_state_access')
# GL/glext.h:7987
glPushClientAttribDefaultEXT = _link_function('glPushClientAttribDefaultEXT', None, [GLbitfield], 'EXT_direct_state_access')
# GL/glext.h:7988
glMatrixLoadfEXT = _link_function('glMatrixLoadfEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:7989
glMatrixLoaddEXT = _link_function('glMatrixLoaddEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:7990
glMatrixMultfEXT = _link_function('glMatrixMultfEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:7991
glMatrixMultdEXT = _link_function('glMatrixMultdEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:7992
glMatrixLoadIdentityEXT = _link_function('glMatrixLoadIdentityEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:7993
glMatrixRotatefEXT = _link_function('glMatrixRotatefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:7994
glMatrixRotatedEXT = _link_function('glMatrixRotatedEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:7995
glMatrixScalefEXT = _link_function('glMatrixScalefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:7996
glMatrixScaledEXT = _link_function('glMatrixScaledEXT', None, [GLenum, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:7997
glMatrixTranslatefEXT = _link_function('glMatrixTranslatefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:7998
glMatrixTranslatedEXT = _link_function('glMatrixTranslatedEXT', None, [GLenum, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:7999
glMatrixFrustumEXT = _link_function('glMatrixFrustumEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:8000
glMatrixOrthoEXT = _link_function('glMatrixOrthoEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:8001
glMatrixPopEXT = _link_function('glMatrixPopEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:8002
glMatrixPushEXT = _link_function('glMatrixPushEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:8003
glMatrixLoadTransposefEXT = _link_function('glMatrixLoadTransposefEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8004
glMatrixLoadTransposedEXT = _link_function('glMatrixLoadTransposedEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8005
glMatrixMultTransposefEXT = _link_function('glMatrixMultTransposefEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8006
glMatrixMultTransposedEXT = _link_function('glMatrixMultTransposedEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8007
glTextureParameterfEXT = _link_function('glTextureParameterfEXT', None, [GLuint, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8008
glTextureParameterfvEXT = _link_function('glTextureParameterfvEXT', None, [GLuint, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8009
glTextureParameteriEXT = _link_function('glTextureParameteriEXT', None, [GLuint, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:8010
glTextureParameterivEXT = _link_function('glTextureParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8011
glTextureImage1DEXT = _link_function('glTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8012
glTextureImage2DEXT = _link_function('glTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8013
glTextureSubImage1DEXT = _link_function('glTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8014
glTextureSubImage2DEXT = _link_function('glTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8015
glCopyTextureImage1DEXT = _link_function('glCopyTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:8016
glCopyTextureImage2DEXT = _link_function('glCopyTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:8017
glCopyTextureSubImage1DEXT = _link_function('glCopyTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8018
glCopyTextureSubImage2DEXT = _link_function('glCopyTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8019
glGetTextureImageEXT = _link_function('glGetTextureImageEXT', None, [GLuint, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8020
glGetTextureParameterfvEXT = _link_function('glGetTextureParameterfvEXT', None, [GLuint, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8021
glGetTextureParameterivEXT = _link_function('glGetTextureParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8022
glGetTextureLevelParameterfvEXT = _link_function('glGetTextureLevelParameterfvEXT', None, [GLuint, GLenum, GLint, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8023
glGetTextureLevelParameterivEXT = _link_function('glGetTextureLevelParameterivEXT', None, [GLuint, GLenum, GLint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8024
glTextureImage3DEXT = _link_function('glTextureImage3DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8025
glTextureSubImage3DEXT = _link_function('glTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8026
glCopyTextureSubImage3DEXT = _link_function('glCopyTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8027
glMultiTexParameterfEXT = _link_function('glMultiTexParameterfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8028
glMultiTexParameterfvEXT = _link_function('glMultiTexParameterfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8029
glMultiTexParameteriEXT = _link_function('glMultiTexParameteriEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:8030
glMultiTexParameterivEXT = _link_function('glMultiTexParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8031
glMultiTexImage1DEXT = _link_function('glMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8032
glMultiTexImage2DEXT = _link_function('glMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8033
glMultiTexSubImage1DEXT = _link_function('glMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8034
glMultiTexSubImage2DEXT = _link_function('glMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8035
glCopyMultiTexImage1DEXT = _link_function('glCopyMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:8036
glCopyMultiTexImage2DEXT = _link_function('glCopyMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:8037
glCopyMultiTexSubImage1DEXT = _link_function('glCopyMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8038
glCopyMultiTexSubImage2DEXT = _link_function('glCopyMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8039
glGetMultiTexImageEXT = _link_function('glGetMultiTexImageEXT', None, [GLenum, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8040
glGetMultiTexParameterfvEXT = _link_function('glGetMultiTexParameterfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8041
glGetMultiTexParameterivEXT = _link_function('glGetMultiTexParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8042
glGetMultiTexLevelParameterfvEXT = _link_function('glGetMultiTexLevelParameterfvEXT', None, [GLenum, GLenum, GLint, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8043
glGetMultiTexLevelParameterivEXT = _link_function('glGetMultiTexLevelParameterivEXT', None, [GLenum, GLenum, GLint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8044
glMultiTexImage3DEXT = _link_function('glMultiTexImage3DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8045
glMultiTexSubImage3DEXT = _link_function('glMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8046
glCopyMultiTexSubImage3DEXT = _link_function('glCopyMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8047
glBindMultiTextureEXT = _link_function('glBindMultiTextureEXT', None, [GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8048
glEnableClientStateIndexedEXT = _link_function('glEnableClientStateIndexedEXT', None, [GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8049
glDisableClientStateIndexedEXT = _link_function('glDisableClientStateIndexedEXT', None, [GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8050
glMultiTexCoordPointerEXT = _link_function('glMultiTexCoordPointerEXT', None, [GLenum, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8051
glMultiTexEnvfEXT = _link_function('glMultiTexEnvfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8052
glMultiTexEnvfvEXT = _link_function('glMultiTexEnvfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8053
glMultiTexEnviEXT = _link_function('glMultiTexEnviEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:8054
glMultiTexEnvivEXT = _link_function('glMultiTexEnvivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8055
glMultiTexGendEXT = _link_function('glMultiTexGendEXT', None, [GLenum, GLenum, GLenum, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:8056
glMultiTexGendvEXT = _link_function('glMultiTexGendvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8057
glMultiTexGenfEXT = _link_function('glMultiTexGenfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8058
glMultiTexGenfvEXT = _link_function('glMultiTexGenfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8059
glMultiTexGeniEXT = _link_function('glMultiTexGeniEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:8060
glMultiTexGenivEXT = _link_function('glMultiTexGenivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8061
glGetMultiTexEnvfvEXT = _link_function('glGetMultiTexEnvfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8062
glGetMultiTexEnvivEXT = _link_function('glGetMultiTexEnvivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8063
glGetMultiTexGendvEXT = _link_function('glGetMultiTexGendvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8064
glGetMultiTexGenfvEXT = _link_function('glGetMultiTexGenfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8065
glGetMultiTexGenivEXT = _link_function('glGetMultiTexGenivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8066
glGetFloatIndexedvEXT = _link_function('glGetFloatIndexedvEXT', None, [GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8067
glGetDoubleIndexedvEXT = _link_function('glGetDoubleIndexedvEXT', None, [GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8068
glGetPointerIndexedvEXT = _link_function('glGetPointerIndexedvEXT', None, [GLenum, GLuint, POINTER(POINTER(GLvoid))], 'EXT_direct_state_access')
# GL/glext.h:8069
glCompressedTextureImage3DEXT = _link_function('glCompressedTextureImage3DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8070
glCompressedTextureImage2DEXT = _link_function('glCompressedTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8071
glCompressedTextureImage1DEXT = _link_function('glCompressedTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8072
glCompressedTextureSubImage3DEXT = _link_function('glCompressedTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8073
glCompressedTextureSubImage2DEXT = _link_function('glCompressedTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8074
glCompressedTextureSubImage1DEXT = _link_function('glCompressedTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8075
glGetCompressedTextureImageEXT = _link_function('glGetCompressedTextureImageEXT', None, [GLuint, GLenum, GLint, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8076
glCompressedMultiTexImage3DEXT = _link_function('glCompressedMultiTexImage3DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8077
glCompressedMultiTexImage2DEXT = _link_function('glCompressedMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8078
glCompressedMultiTexImage1DEXT = _link_function('glCompressedMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8079
glCompressedMultiTexSubImage3DEXT = _link_function('glCompressedMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8080
glCompressedMultiTexSubImage2DEXT = _link_function('glCompressedMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8081
glCompressedMultiTexSubImage1DEXT = _link_function('glCompressedMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8082
glGetCompressedMultiTexImageEXT = _link_function('glGetCompressedMultiTexImageEXT', None, [GLenum, GLenum, GLint, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8083
glNamedProgramStringEXT = _link_function('glNamedProgramStringEXT', None, [GLuint, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8084
glNamedProgramLocalParameter4dEXT = _link_function('glNamedProgramLocalParameter4dEXT', None, [GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:8085
glNamedProgramLocalParameter4dvEXT = _link_function('glNamedProgramLocalParameter4dvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8086
glNamedProgramLocalParameter4fEXT = _link_function('glNamedProgramLocalParameter4fEXT', None, [GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8087
glNamedProgramLocalParameter4fvEXT = _link_function('glNamedProgramLocalParameter4fvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8088
glGetNamedProgramLocalParameterdvEXT = _link_function('glGetNamedProgramLocalParameterdvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:8089
glGetNamedProgramLocalParameterfvEXT = _link_function('glGetNamedProgramLocalParameterfvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8090
glGetNamedProgramivEXT = _link_function('glGetNamedProgramivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8091
glGetNamedProgramStringEXT = _link_function('glGetNamedProgramStringEXT', None, [GLuint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8092
glNamedProgramLocalParameters4fvEXT = _link_function('glNamedProgramLocalParameters4fvEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8093
glNamedProgramLocalParameterI4iEXT = _link_function('glNamedProgramLocalParameterI4iEXT', None, [GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8094
glNamedProgramLocalParameterI4ivEXT = _link_function('glNamedProgramLocalParameterI4ivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8095
glNamedProgramLocalParametersI4ivEXT = _link_function('glNamedProgramLocalParametersI4ivEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8096
glNamedProgramLocalParameterI4uiEXT = _link_function('glNamedProgramLocalParameterI4uiEXT', None, [GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8097
glNamedProgramLocalParameterI4uivEXT = _link_function('glNamedProgramLocalParameterI4uivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8098
glNamedProgramLocalParametersI4uivEXT = _link_function('glNamedProgramLocalParametersI4uivEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8099
glGetNamedProgramLocalParameterIivEXT = _link_function('glGetNamedProgramLocalParameterIivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8100
glGetNamedProgramLocalParameterIuivEXT = _link_function('glGetNamedProgramLocalParameterIuivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8101
glTextureParameterIivEXT = _link_function('glTextureParameterIivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8102
glTextureParameterIuivEXT = _link_function('glTextureParameterIuivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8103
glGetTextureParameterIivEXT = _link_function('glGetTextureParameterIivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8104
glGetTextureParameterIuivEXT = _link_function('glGetTextureParameterIuivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8105
glMultiTexParameterIivEXT = _link_function('glMultiTexParameterIivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8106
glMultiTexParameterIuivEXT = _link_function('glMultiTexParameterIuivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8107
glGetMultiTexParameterIivEXT = _link_function('glGetMultiTexParameterIivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8108
glGetMultiTexParameterIuivEXT = _link_function('glGetMultiTexParameterIuivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8109
glProgramUniform1fEXT = _link_function('glProgramUniform1fEXT', None, [GLuint, GLint, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8110
glProgramUniform2fEXT = _link_function('glProgramUniform2fEXT', None, [GLuint, GLint, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8111
glProgramUniform3fEXT = _link_function('glProgramUniform3fEXT', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8112
glProgramUniform4fEXT = _link_function('glProgramUniform4fEXT', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:8113
glProgramUniform1iEXT = _link_function('glProgramUniform1iEXT', None, [GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8114
glProgramUniform2iEXT = _link_function('glProgramUniform2iEXT', None, [GLuint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8115
glProgramUniform3iEXT = _link_function('glProgramUniform3iEXT', None, [GLuint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8116
glProgramUniform4iEXT = _link_function('glProgramUniform4iEXT', None, [GLuint, GLint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8117
glProgramUniform1fvEXT = _link_function('glProgramUniform1fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8118
glProgramUniform2fvEXT = _link_function('glProgramUniform2fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8119
glProgramUniform3fvEXT = _link_function('glProgramUniform3fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8120
glProgramUniform4fvEXT = _link_function('glProgramUniform4fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8121
glProgramUniform1ivEXT = _link_function('glProgramUniform1ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8122
glProgramUniform2ivEXT = _link_function('glProgramUniform2ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8123
glProgramUniform3ivEXT = _link_function('glProgramUniform3ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8124
glProgramUniform4ivEXT = _link_function('glProgramUniform4ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8125
glProgramUniformMatrix2fvEXT = _link_function('glProgramUniformMatrix2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8126
glProgramUniformMatrix3fvEXT = _link_function('glProgramUniformMatrix3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8127
glProgramUniformMatrix4fvEXT = _link_function('glProgramUniformMatrix4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8128
glProgramUniformMatrix2x3fvEXT = _link_function('glProgramUniformMatrix2x3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8129
glProgramUniformMatrix3x2fvEXT = _link_function('glProgramUniformMatrix3x2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8130
glProgramUniformMatrix2x4fvEXT = _link_function('glProgramUniformMatrix2x4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8131
glProgramUniformMatrix4x2fvEXT = _link_function('glProgramUniformMatrix4x2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8132
glProgramUniformMatrix3x4fvEXT = _link_function('glProgramUniformMatrix3x4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8133
glProgramUniformMatrix4x3fvEXT = _link_function('glProgramUniformMatrix4x3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:8134
glProgramUniform1uiEXT = _link_function('glProgramUniform1uiEXT', None, [GLuint, GLint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8135
glProgramUniform2uiEXT = _link_function('glProgramUniform2uiEXT', None, [GLuint, GLint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8136
glProgramUniform3uiEXT = _link_function('glProgramUniform3uiEXT', None, [GLuint, GLint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8137
glProgramUniform4uiEXT = _link_function('glProgramUniform4uiEXT', None, [GLuint, GLint, GLuint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8138
glProgramUniform1uivEXT = _link_function('glProgramUniform1uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8139
glProgramUniform2uivEXT = _link_function('glProgramUniform2uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8140
glProgramUniform3uivEXT = _link_function('glProgramUniform3uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8141
glProgramUniform4uivEXT = _link_function('glProgramUniform4uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:8142
glNamedBufferDataEXT = _link_function('glNamedBufferDataEXT', None, [GLuint, GLsizeiptr, POINTER(GLvoid), GLenum], 'EXT_direct_state_access')
# GL/glext.h:8143
glNamedBufferSubDataEXT = _link_function('glNamedBufferSubDataEXT', None, [GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8144
glMapNamedBufferEXT = _link_function('glMapNamedBufferEXT', POINTER(GLvoid), [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8145
glUnmapNamedBufferEXT = _link_function('glUnmapNamedBufferEXT', GLboolean, [GLuint], 'EXT_direct_state_access')
# GL/glext.h:8146
glGetNamedBufferParameterivEXT = _link_function('glGetNamedBufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8147
glGetNamedBufferPointervEXT = _link_function('glGetNamedBufferPointervEXT', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'EXT_direct_state_access')
# GL/glext.h:8148
glGetNamedBufferSubDataEXT = _link_function('glGetNamedBufferSubDataEXT', None, [GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:8149
glTextureBufferEXT = _link_function('glTextureBufferEXT', None, [GLuint, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8150
glMultiTexBufferEXT = _link_function('glMultiTexBufferEXT', None, [GLenum, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8151
glNamedRenderbufferStorageEXT = _link_function('glNamedRenderbufferStorageEXT', None, [GLuint, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8152
glGetNamedRenderbufferParameterivEXT = _link_function('glGetNamedRenderbufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8153
glCheckNamedFramebufferStatusEXT = _link_function('glCheckNamedFramebufferStatusEXT', GLenum, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8154
glNamedFramebufferTexture1DEXT = _link_function('glNamedFramebufferTexture1DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8155
glNamedFramebufferTexture2DEXT = _link_function('glNamedFramebufferTexture2DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8156
glNamedFramebufferTexture3DEXT = _link_function('glNamedFramebufferTexture3DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8157
glNamedFramebufferRenderbufferEXT = _link_function('glNamedFramebufferRenderbufferEXT', None, [GLuint, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8158
glGetNamedFramebufferAttachmentParameterivEXT = _link_function('glGetNamedFramebufferAttachmentParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8159
glGenerateTextureMipmapEXT = _link_function('glGenerateTextureMipmapEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8160
glGenerateMultiTexMipmapEXT = _link_function('glGenerateMultiTexMipmapEXT', None, [GLenum, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8161
glFramebufferDrawBufferEXT = _link_function('glFramebufferDrawBufferEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8162
glFramebufferDrawBuffersEXT = _link_function('glFramebufferDrawBuffersEXT', None, [GLuint, GLsizei, POINTER(GLenum)], 'EXT_direct_state_access')
# GL/glext.h:8163
glFramebufferReadBufferEXT = _link_function('glFramebufferReadBufferEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8164
glGetFramebufferParameterivEXT = _link_function('glGetFramebufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:8165
glNamedRenderbufferStorageMultisampleEXT = _link_function('glNamedRenderbufferStorageMultisampleEXT', None, [GLuint, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8166
glNamedRenderbufferStorageMultisampleCoverageEXT = _link_function('glNamedRenderbufferStorageMultisampleCoverageEXT', None, [GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:8167
glNamedFramebufferTextureEXT = _link_function('glNamedFramebufferTextureEXT', None, [GLuint, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8168
glNamedFramebufferTextureLayerEXT = _link_function('glNamedFramebufferTextureLayerEXT', None, [GLuint, GLenum, GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:8169
glNamedFramebufferTextureFaceEXT = _link_function('glNamedFramebufferTextureFaceEXT', None, [GLuint, GLenum, GLuint, GLint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:8170
glTextureRenderbufferEXT = _link_function('glTextureRenderbufferEXT', None, [GLuint, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:8171
glMultiTexRenderbufferEXT = _link_function('glMultiTexRenderbufferEXT', None, [GLenum, GLenum, GLuint], 'EXT_direct_state_access')
PFNGLCLIENTATTRIBDEFAULTEXTPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:8173
PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:8174
PFNGLMATRIXLOADFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8175
PFNGLMATRIXLOADDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:8176
PFNGLMATRIXMULTFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8177
PFNGLMATRIXMULTDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:8178
PFNGLMATRIXLOADIDENTITYEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8179
PFNGLMATRIXROTATEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8180
PFNGLMATRIXROTATEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:8181
PFNGLMATRIXSCALEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:8182
PFNGLMATRIXSCALEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:8183
PFNGLMATRIXTRANSLATEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:8184
PFNGLMATRIXTRANSLATEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:8185
PFNGLMATRIXFRUSTUMEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:8186
PFNGLMATRIXORTHOEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:8187
PFNGLMATRIXPOPEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8188
PFNGLMATRIXPUSHEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8189
PFNGLMATRIXLOADTRANSPOSEFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8190
PFNGLMATRIXLOADTRANSPOSEDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:8191
PFNGLMATRIXMULTTRANSPOSEFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8192
PFNGLMATRIXMULTTRANSPOSEDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:8193
PFNGLTEXTUREPARAMETERFEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLfloat) # GL/glext.h:8194
PFNGLTEXTUREPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8195
PFNGLTEXTUREPARAMETERIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLint) # GL/glext.h:8196
PFNGLTEXTUREPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8197
PFNGLTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8198
PFNGLTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8199
PFNGLTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8200
PFNGLTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8201
PFNGLCOPYTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:8202
PFNGLCOPYTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:8203
PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:8204
PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:8205
PFNGLGETTEXTUREIMAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8206
PFNGLGETTEXTUREPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8207
PFNGLGETTEXTUREPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8208
PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, POINTER(GLfloat)) # GL/glext.h:8209
PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, POINTER(GLint)) # GL/glext.h:8210
PFNGLTEXTUREIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8211
PFNGLTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8212
PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:8213
PFNGLMULTITEXPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:8214
PFNGLMULTITEXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8215
PFNGLMULTITEXPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:8216
PFNGLMULTITEXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8217
PFNGLMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8218
PFNGLMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8219
PFNGLMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8220
PFNGLMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8221
PFNGLCOPYMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:8222
PFNGLCOPYMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:8223
PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:8224
PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:8225
PFNGLGETMULTITEXIMAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8226
PFNGLGETMULTITEXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8227
PFNGLGETMULTITEXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8228
PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, POINTER(GLfloat)) # GL/glext.h:8229
PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, POINTER(GLint)) # GL/glext.h:8230
PFNGLMULTITEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8231
PFNGLMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8232
PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:8233
PFNGLBINDMULTITEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:8234
PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8235
PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8236
PFNGLMULTITEXCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8237
PFNGLMULTITEXENVFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:8238
PFNGLMULTITEXENVFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8239
PFNGLMULTITEXENVIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:8240
PFNGLMULTITEXENVIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8241
PFNGLMULTITEXGENDEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLdouble) # GL/glext.h:8242
PFNGLMULTITEXGENDVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLdouble)) # GL/glext.h:8243
PFNGLMULTITEXGENFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:8244
PFNGLMULTITEXGENFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8245
PFNGLMULTITEXGENIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:8246
PFNGLMULTITEXGENIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8247
PFNGLGETMULTITEXENVFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8248
PFNGLGETMULTITEXENVIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8249
PFNGLGETMULTITEXGENDVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLdouble)) # GL/glext.h:8250
PFNGLGETMULTITEXGENFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8251
PFNGLGETMULTITEXGENIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8252
PFNGLGETFLOATINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:8253
PFNGLGETDOUBLEINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:8254
PFNGLGETPOINTERINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(POINTER(GLvoid))) # GL/glext.h:8255
PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8256
PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8257
PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8258
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8259
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8260
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8261
PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:8262
PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8263
PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8264
PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:8265
PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8266
PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8267
PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8268
PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:8269
PFNGLNAMEDPROGRAMSTRINGEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8270
PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:8271
PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:8272
PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8273
PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:8274
PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:8275
PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:8276
PFNGLGETNAMEDPROGRAMIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8277
PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8278
PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:8279
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:8280
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:8281
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:8282
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:8283
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:8284
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:8285
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:8286
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:8287
PFNGLTEXTUREPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8288
PFNGLTEXTUREPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:8289
PFNGLGETTEXTUREPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8290
PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:8291
PFNGLMULTITEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8292
PFNGLMULTITEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:8293
PFNGLGETMULTITEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8294
PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:8295
PFNGLPROGRAMUNIFORM1FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat) # GL/glext.h:8296
PFNGLPROGRAMUNIFORM2FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat) # GL/glext.h:8297
PFNGLPROGRAMUNIFORM3FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:8298
PFNGLPROGRAMUNIFORM4FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8299
PFNGLPROGRAMUNIFORM1IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:8300
PFNGLPROGRAMUNIFORM2IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:8301
PFNGLPROGRAMUNIFORM3IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:8302
PFNGLPROGRAMUNIFORM4IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:8303
PFNGLPROGRAMUNIFORM1FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:8304
PFNGLPROGRAMUNIFORM2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:8305
PFNGLPROGRAMUNIFORM3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:8306
PFNGLPROGRAMUNIFORM4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:8307
PFNGLPROGRAMUNIFORM1IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:8308
PFNGLPROGRAMUNIFORM2IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:8309
PFNGLPROGRAMUNIFORM3IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:8310
PFNGLPROGRAMUNIFORM4IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:8311
PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8312
PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8313
PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8314
PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8315
PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8316
PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8317
PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8318
PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8319
PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:8320
PFNGLPROGRAMUNIFORM1UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:8321
PFNGLPROGRAMUNIFORM2UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint) # GL/glext.h:8322
PFNGLPROGRAMUNIFORM3UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint) # GL/glext.h:8323
PFNGLPROGRAMUNIFORM4UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:8324
PFNGLPROGRAMUNIFORM1UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:8325
PFNGLPROGRAMUNIFORM2UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:8326
PFNGLPROGRAMUNIFORM3UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:8327
PFNGLPROGRAMUNIFORM4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:8328
PFNGLNAMEDBUFFERDATAEXTPROC = CFUNCTYPE(None, GLuint, GLsizeiptr, POINTER(GLvoid), GLenum) # GL/glext.h:8329
PFNGLNAMEDBUFFERSUBDATAEXTPROC = CFUNCTYPE(None, GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:8330
PFNGLMAPNAMEDBUFFEREXTPROC = CFUNCTYPE(POINTER(GLvoid), GLuint, GLenum) # GL/glext.h:8331
PFNGLUNMAPNAMEDBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:8332
PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:8333
PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8334
PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = CFUNCTYPE(None, GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:8335
PFNGLTEXTUREBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint) # GL/glext.h:8336
PFNGLMULTITEXBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:8337
PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLsizei) # GL/glext.h:8338
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:8339
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = CFUNCTYPE(GLenum, GLuint, GLenum) # GL/glext.h:8340
PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint) # GL/glext.h:8341
PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint) # GL/glext.h:8342
PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:8343
PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint) # GL/glext.h:8344
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8345
PFNGLGENERATETEXTUREMIPMAPEXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:8346
PFNGLGENERATEMULTITEXMIPMAPEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:8347
PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:8348
PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLenum)) # GL/glext.h:8349
PFNGLFRAMEBUFFERREADBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:8350
PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:8351
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:8352
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:8353
PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint) # GL/glext.h:8354
PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLint) # GL/glext.h:8355
PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLenum) # GL/glext.h:8356
PFNGLTEXTURERENDERBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint) # GL/glext.h:8357
PFNGLMULTITEXRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:8358
# EXT_vertex_array_bgra (GL/glext.h:8361)
GL_EXT_vertex_array_bgra = 1 # GL/glext.h:8362
# EXT_texture_swizzle (GL/glext.h:8365)
GL_EXT_texture_swizzle = 1 # GL/glext.h:8366
# NV_explicit_multisample (GL/glext.h:8369)
GL_NV_explicit_multisample = 1 # GL/glext.h:8370
# GL/glext.h:8372
glGetMultisamplefvNV = _link_function('glGetMultisamplefvNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_explicit_multisample')
# GL/glext.h:8373
glSampleMaskIndexedNV = _link_function('glSampleMaskIndexedNV', None, [GLuint, GLbitfield], 'NV_explicit_multisample')
# GL/glext.h:8374
glTexRenderbufferNV = _link_function('glTexRenderbufferNV', None, [GLenum, GLuint], 'NV_explicit_multisample')
PFNGLGETMULTISAMPLEFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:8376
PFNGLSAMPLEMASKINDEXEDNVPROC = CFUNCTYPE(None, GLuint, GLbitfield) # GL/glext.h:8377
PFNGLTEXRENDERBUFFERNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8378
# NV_transform_feedback2 (GL/glext.h:8381)
GL_NV_transform_feedback2 = 1 # GL/glext.h:8382
# GL/glext.h:8384
glBindTransformFeedbackNV = _link_function('glBindTransformFeedbackNV', None, [GLenum, GLuint], 'NV_transform_feedback2')
# GL/glext.h:8385
glDeleteTransformFeedbacksNV = _link_function('glDeleteTransformFeedbacksNV', None, [GLsizei, POINTER(GLuint)], 'NV_transform_feedback2')
# GL/glext.h:8386
glGenTransformFeedbacksNV = _link_function('glGenTransformFeedbacksNV', None, [GLsizei, POINTER(GLuint)], 'NV_transform_feedback2')
# GL/glext.h:8387
glIsTransformFeedbackNV = _link_function('glIsTransformFeedbackNV', GLboolean, [GLuint], 'NV_transform_feedback2')
# GL/glext.h:8388
glPauseTransformFeedbackNV = _link_function('glPauseTransformFeedbackNV', None, [], 'NV_transform_feedback2')
# GL/glext.h:8389
glResumeTransformFeedbackNV = _link_function('glResumeTransformFeedbackNV', None, [], 'NV_transform_feedback2')
# GL/glext.h:8390
glDrawTransformFeedbackNV = _link_function('glDrawTransformFeedbackNV', None, [GLenum, GLuint], 'NV_transform_feedback2')
PFNGLBINDTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8392
PFNGLDELETETRANSFORMFEEDBACKSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:8393
PFNGLGENTRANSFORMFEEDBACKSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:8394
PFNGLISTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:8395
PFNGLPAUSETRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:8396
PFNGLRESUMETRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:8397
PFNGLDRAWTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8398
# NV_vertex_buffer_unified_memory (GL/glext.h:8401)
GL_NV_vertex_buffer_unified_memory = 1 # GL/glext.h:8402
# GL/glext.h:8404
glBufferAddressRangeNV = _link_function('glBufferAddressRangeNV', None, [GLenum, GLuint, GLuint64EXT, GLsizeiptr], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8405
glVertexFormatNV = _link_function('glVertexFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8406
glNormalFormatNV = _link_function('glNormalFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8407
glColorFormatNV = _link_function('glColorFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8408
glIndexFormatNV = _link_function('glIndexFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8409
glTexCoordFormatNV = _link_function('glTexCoordFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8410
glEdgeFlagFormatNV = _link_function('glEdgeFlagFormatNV', None, [GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8411
glSecondaryColorFormatNV = _link_function('glSecondaryColorFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8412
glFogCoordFormatNV = _link_function('glFogCoordFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8413
glVertexAttribFormatNV = _link_function('glVertexAttribFormatNV', None, [GLuint, GLint, GLenum, GLboolean, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8414
glVertexAttribIFormatNV = _link_function('glVertexAttribIFormatNV', None, [GLuint, GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:8415
glGetIntegerui64i_vNV = _link_function('glGetIntegerui64i_vNV', None, [GLenum, GLuint, POINTER(GLuint64EXT)], 'NV_vertex_buffer_unified_memory')
PFNGLBUFFERADDRESSRANGENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint64EXT, GLsizeiptr) # GL/glext.h:8417
PFNGLVERTEXFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:8418
PFNGLNORMALFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:8419
PFNGLCOLORFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:8420
PFNGLINDEXFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:8421
PFNGLTEXCOORDFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:8422
PFNGLEDGEFLAGFORMATNVPROC = CFUNCTYPE(None, GLsizei) # GL/glext.h:8423
PFNGLSECONDARYCOLORFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:8424
PFNGLFOGCOORDFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:8425
PFNGLVERTEXATTRIBFORMATNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei) # GL/glext.h:8426
PFNGLVERTEXATTRIBIFORMATNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei) # GL/glext.h:8427
PFNGLGETINTEGERUI64I_VNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:8428
# NV_shader_buffer_load (GL/glext.h:8432)
GL_NV_shader_buffer_load = 1 # GL/glext.h:8433
# GL/glext.h:8435
glGetBufferParameterui64vNV = _link_function('glGetBufferParameterui64vNV', None, [GLenum, GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:8436
glGetIntegerui64vNV = _link_function('glGetIntegerui64vNV', None, [GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:8437
glGetNamedBufferParameterui64vNV = _link_function('glGetNamedBufferParameterui64vNV', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:8438
glIsBufferResidentNV = _link_function('glIsBufferResidentNV', GLboolean, [GLenum], 'NV_shader_buffer_load')
# GL/glext.h:8439
glIsNamedBufferResidentNV = _link_function('glIsNamedBufferResidentNV', GLboolean, [GLuint], 'NV_shader_buffer_load')
# GL/glext.h:8440
glMakeBufferNonResidentNV = _link_function('glMakeBufferNonResidentNV', None, [GLenum], 'NV_shader_buffer_load')
# GL/glext.h:8441
glMakeBufferResidentNV = _link_function('glMakeBufferResidentNV', None, [GLenum, GLenum], 'NV_shader_buffer_load')
# GL/glext.h:8442
glMakeNamedBufferNonResidentNV = _link_function('glMakeNamedBufferNonResidentNV', None, [GLuint], 'NV_shader_buffer_load')
# GL/glext.h:8443
glMakeNamedBufferResidentNV = _link_function('glMakeNamedBufferResidentNV', None, [GLuint, GLenum], 'NV_shader_buffer_load')
# GL/glext.h:8444
glUniformui64NV = _link_function('glUniformui64NV', None, [GLint, GLuint64EXT], 'NV_shader_buffer_load')
# GL/glext.h:8445
glUniformui64vNV = _link_function('glUniformui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:8446
glGetUniformui64vNV = _link_function('glGetUniformui64vNV', None, [GLuint, GLint, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:8447
glProgramUniformui64NV = _link_function('glProgramUniformui64NV', None, [GLuint, GLint, GLuint64EXT], 'NV_shader_buffer_load')
# GL/glext.h:8448
glProgramUniformui64vNV = _link_function('glProgramUniformui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
PFNGLGETBUFFERPARAMETERUI64VNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:8450
PFNGLGETINTEGERUI64VNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:8451
PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:8452
PFNGLISBUFFERRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:8453
PFNGLISNAMEDBUFFERRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:8454
PFNGLMAKEBUFFERNONRESIDENTNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8455
PFNGLMAKEBUFFERRESIDENTNVPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:8456
PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:8457
PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:8458
PFNGLUNIFORMUI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT) # GL/glext.h:8459
PFNGLUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:8460
PFNGLGETUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint64EXT)) # GL/glext.h:8461
PFNGLPROGRAMUNIFORMUI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT) # GL/glext.h:8462
PFNGLPROGRAMUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:8463
# MESA_shader_debug (/usr/include/GL/gl.h:2093)
# MESA_packed_depth_stencil (/usr/include/GL/gl.h:2115)
# MESA_program_debug (/usr/include/GL/gl.h:2127)
# MESA_texture_array (/usr/include/GL/gl.h:2148)
# EXT_texture_array (/usr/include/GL/gl.h:2153)
# ATI_blend_equation_separate (/usr/include/GL/gl.h:2181)
# OES_EGL_image (/usr/include/GL/gl.h:2193)
# OES_EGL_image (/usr/include/GL/gl.h:2197)
__all__ = ['GL_GLEXT_VERSION', 'GL_BLEND_DST_RGB', 'GL_BLEND_SRC_RGB',
'GL_BLEND_DST_ALPHA', 'GL_BLEND_SRC_ALPHA', 'GL_POINT_SIZE_MIN',
'GL_POINT_SIZE_MAX', 'GL_POINT_FADE_THRESHOLD_SIZE',
'GL_POINT_DISTANCE_ATTENUATION', 'GL_GENERATE_MIPMAP',
'GL_GENERATE_MIPMAP_HINT', 'GL_DEPTH_COMPONENT16', 'GL_DEPTH_COMPONENT24',
'GL_DEPTH_COMPONENT32', 'GL_MIRRORED_REPEAT', 'GL_FOG_COORDINATE_SOURCE',
'GL_FOG_COORDINATE', 'GL_FRAGMENT_DEPTH', 'GL_CURRENT_FOG_COORDINATE',
'GL_FOG_COORDINATE_ARRAY_TYPE', 'GL_FOG_COORDINATE_ARRAY_STRIDE',
'GL_FOG_COORDINATE_ARRAY_POINTER', 'GL_FOG_COORDINATE_ARRAY', 'GL_COLOR_SUM',
'GL_CURRENT_SECONDARY_COLOR', 'GL_SECONDARY_COLOR_ARRAY_SIZE',
'GL_SECONDARY_COLOR_ARRAY_TYPE', 'GL_SECONDARY_COLOR_ARRAY_STRIDE',
'GL_SECONDARY_COLOR_ARRAY_POINTER', 'GL_SECONDARY_COLOR_ARRAY',
'GL_MAX_TEXTURE_LOD_BIAS', 'GL_TEXTURE_FILTER_CONTROL', 'GL_TEXTURE_LOD_BIAS',
'GL_INCR_WRAP', 'GL_DECR_WRAP', 'GL_TEXTURE_DEPTH_SIZE',
'GL_DEPTH_TEXTURE_MODE', 'GL_TEXTURE_COMPARE_MODE', 'GL_TEXTURE_COMPARE_FUNC',
'GL_COMPARE_R_TO_TEXTURE', 'GL_BUFFER_SIZE', 'GL_BUFFER_USAGE',
'GL_QUERY_COUNTER_BITS', 'GL_CURRENT_QUERY', 'GL_QUERY_RESULT',
'GL_QUERY_RESULT_AVAILABLE', 'GL_ARRAY_BUFFER', 'GL_ELEMENT_ARRAY_BUFFER',
'GL_ARRAY_BUFFER_BINDING', 'GL_ELEMENT_ARRAY_BUFFER_BINDING',
'GL_VERTEX_ARRAY_BUFFER_BINDING', 'GL_NORMAL_ARRAY_BUFFER_BINDING',
'GL_COLOR_ARRAY_BUFFER_BINDING', 'GL_INDEX_ARRAY_BUFFER_BINDING',
'GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING', 'GL_EDGE_FLAG_ARRAY_BUFFER_BINDING',
'GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING',
'GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING', 'GL_WEIGHT_ARRAY_BUFFER_BINDING',
'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING', 'GL_READ_ONLY', 'GL_WRITE_ONLY',
'GL_READ_WRITE', 'GL_BUFFER_ACCESS', 'GL_BUFFER_MAPPED',
'GL_BUFFER_MAP_POINTER', 'GL_STREAM_DRAW', 'GL_STREAM_READ', 'GL_STREAM_COPY',
'GL_STATIC_DRAW', 'GL_STATIC_READ', 'GL_STATIC_COPY', 'GL_DYNAMIC_DRAW',
'GL_DYNAMIC_READ', 'GL_DYNAMIC_COPY', 'GL_SAMPLES_PASSED', 'GL_FOG_COORD_SRC',
'GL_FOG_COORD', 'GL_CURRENT_FOG_COORD', 'GL_FOG_COORD_ARRAY_TYPE',
'GL_FOG_COORD_ARRAY_STRIDE', 'GL_FOG_COORD_ARRAY_POINTER',
'GL_FOG_COORD_ARRAY', 'GL_FOG_COORD_ARRAY_BUFFER_BINDING', 'GL_SRC0_RGB',
'GL_SRC1_RGB', 'GL_SRC2_RGB', 'GL_SRC0_ALPHA', 'GL_SRC1_ALPHA',
'GL_SRC2_ALPHA', 'GL_BLEND_EQUATION_RGB', 'GL_VERTEX_ATTRIB_ARRAY_ENABLED',
'GL_VERTEX_ATTRIB_ARRAY_SIZE', 'GL_VERTEX_ATTRIB_ARRAY_STRIDE',
'GL_VERTEX_ATTRIB_ARRAY_TYPE', 'GL_CURRENT_VERTEX_ATTRIB',
'GL_VERTEX_PROGRAM_POINT_SIZE', 'GL_VERTEX_PROGRAM_TWO_SIDE',
'GL_VERTEX_ATTRIB_ARRAY_POINTER', 'GL_STENCIL_BACK_FUNC',
'GL_STENCIL_BACK_FAIL', 'GL_STENCIL_BACK_PASS_DEPTH_FAIL',
'GL_STENCIL_BACK_PASS_DEPTH_PASS', 'GL_MAX_DRAW_BUFFERS', 'GL_DRAW_BUFFER0',
'GL_DRAW_BUFFER1', 'GL_DRAW_BUFFER2', 'GL_DRAW_BUFFER3', 'GL_DRAW_BUFFER4',
'GL_DRAW_BUFFER5', 'GL_DRAW_BUFFER6', 'GL_DRAW_BUFFER7', 'GL_DRAW_BUFFER8',
'GL_DRAW_BUFFER9', 'GL_DRAW_BUFFER10', 'GL_DRAW_BUFFER11', 'GL_DRAW_BUFFER12',
'GL_DRAW_BUFFER13', 'GL_DRAW_BUFFER14', 'GL_DRAW_BUFFER15',
'GL_BLEND_EQUATION_ALPHA', 'GL_POINT_SPRITE', 'GL_COORD_REPLACE',
'GL_MAX_VERTEX_ATTRIBS', 'GL_VERTEX_ATTRIB_ARRAY_NORMALIZED',
'GL_MAX_TEXTURE_COORDS', 'GL_MAX_TEXTURE_IMAGE_UNITS', 'GL_FRAGMENT_SHADER',
'GL_VERTEX_SHADER', 'GL_MAX_FRAGMENT_UNIFORM_COMPONENTS',
'GL_MAX_VERTEX_UNIFORM_COMPONENTS', 'GL_MAX_VARYING_FLOATS',
'GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS', 'GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS',
'GL_SHADER_TYPE', 'GL_FLOAT_VEC2', 'GL_FLOAT_VEC3', 'GL_FLOAT_VEC4',
'GL_INT_VEC2', 'GL_INT_VEC3', 'GL_INT_VEC4', 'GL_BOOL', 'GL_BOOL_VEC2',
'GL_BOOL_VEC3', 'GL_BOOL_VEC4', 'GL_FLOAT_MAT2', 'GL_FLOAT_MAT3',
'GL_FLOAT_MAT4', 'GL_SAMPLER_1D', 'GL_SAMPLER_2D', 'GL_SAMPLER_3D',
'GL_SAMPLER_CUBE', 'GL_SAMPLER_1D_SHADOW', 'GL_SAMPLER_2D_SHADOW',
'GL_DELETE_STATUS', 'GL_COMPILE_STATUS', 'GL_LINK_STATUS',
'GL_VALIDATE_STATUS', 'GL_INFO_LOG_LENGTH', 'GL_ATTACHED_SHADERS',
'GL_ACTIVE_UNIFORMS', 'GL_ACTIVE_UNIFORM_MAX_LENGTH',
'GL_SHADER_SOURCE_LENGTH', 'GL_ACTIVE_ATTRIBUTES',
'GL_ACTIVE_ATTRIBUTE_MAX_LENGTH', 'GL_FRAGMENT_SHADER_DERIVATIVE_HINT',
'GL_SHADING_LANGUAGE_VERSION', 'GL_CURRENT_PROGRAM',
'GL_POINT_SPRITE_COORD_ORIGIN', 'GL_LOWER_LEFT', 'GL_UPPER_LEFT',
'GL_STENCIL_BACK_REF', 'GL_STENCIL_BACK_VALUE_MASK',
'GL_STENCIL_BACK_WRITEMASK', 'GL_PIXEL_PACK_BUFFER', 'GL_PIXEL_UNPACK_BUFFER',
'GL_PIXEL_PACK_BUFFER_BINDING', 'GL_PIXEL_UNPACK_BUFFER_BINDING', 'GL_SRGB',
'GL_SRGB8', 'GL_SRGB_ALPHA', 'GL_SRGB8_ALPHA8', 'GL_SLUMINANCE_ALPHA',
'GL_SLUMINANCE8_ALPHA8', 'GL_SLUMINANCE', 'GL_SLUMINANCE8',
'GL_COMPRESSED_SRGB', 'GL_COMPRESSED_SRGB_ALPHA', 'GL_COMPRESSED_SLUMINANCE',
'GL_COMPRESSED_SLUMINANCE_ALPHA', 'GL_FLOAT_MAT2x3', 'GL_FLOAT_MAT2x4',
'GL_FLOAT_MAT3x2', 'GL_FLOAT_MAT3x4', 'GL_FLOAT_MAT4x2', 'GL_FLOAT_MAT4x3',
'GL_CURRENT_RASTER_SECONDARY_COLOR', 'GL_CLIP_DISTANCE0', 'GL_CLIP_DISTANCE1',
'GL_CLIP_DISTANCE2', 'GL_CLIP_DISTANCE3', 'GL_CLIP_DISTANCE4',
'GL_CLIP_DISTANCE5', 'GL_MAX_CLIP_DISTANCES', 'GL_MAJOR_VERSION',
'GL_MINOR_VERSION', 'GL_NUM_EXTENSIONS', 'GL_CONTEXT_FLAGS',
'GL_DEPTH_BUFFER', 'GL_STENCIL_BUFFER', 'GL_COMPRESSED_RED',
'GL_COMPRESSED_RG', 'GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT', 'GL_RGBA32F',
'GL_RGB32F', 'GL_RGBA16F', 'GL_RGB16F', 'GL_VERTEX_ATTRIB_ARRAY_INTEGER',
'GL_MAX_ARRAY_TEXTURE_LAYERS', 'GL_MIN_PROGRAM_TEXEL_OFFSET',
'GL_MAX_PROGRAM_TEXEL_OFFSET', 'GL_CLAMP_VERTEX_COLOR',
'GL_CLAMP_FRAGMENT_COLOR', 'GL_CLAMP_READ_COLOR', 'GL_FIXED_ONLY',
'GL_MAX_VARYING_COMPONENTS', 'GL_TEXTURE_RED_TYPE', 'GL_TEXTURE_GREEN_TYPE',
'GL_TEXTURE_BLUE_TYPE', 'GL_TEXTURE_ALPHA_TYPE', 'GL_TEXTURE_LUMINANCE_TYPE',
'GL_TEXTURE_INTENSITY_TYPE', 'GL_TEXTURE_DEPTH_TYPE',
'GL_UNSIGNED_NORMALIZED', 'GL_TEXTURE_1D_ARRAY', 'GL_PROXY_TEXTURE_1D_ARRAY',
'GL_TEXTURE_2D_ARRAY', 'GL_PROXY_TEXTURE_2D_ARRAY',
'GL_TEXTURE_BINDING_1D_ARRAY', 'GL_TEXTURE_BINDING_2D_ARRAY',
'GL_R11F_G11F_B10F', 'GL_UNSIGNED_INT_10F_11F_11F_REV', 'GL_RGB9_E5',
'GL_UNSIGNED_INT_5_9_9_9_REV', 'GL_TEXTURE_SHARED_SIZE',
'GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH',
'GL_TRANSFORM_FEEDBACK_BUFFER_MODE',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS',
'GL_TRANSFORM_FEEDBACK_VARYINGS', 'GL_TRANSFORM_FEEDBACK_BUFFER_START',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE', 'GL_PRIMITIVES_GENERATED',
'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN', 'GL_RASTERIZER_DISCARD',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS', 'GL_INTERLEAVED_ATTRIBS',
'GL_SEPARATE_ATTRIBS', 'GL_TRANSFORM_FEEDBACK_BUFFER',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING', 'GL_RGBA32UI', 'GL_RGB32UI',
'GL_RGBA16UI', 'GL_RGB16UI', 'GL_RGBA8UI', 'GL_RGB8UI', 'GL_RGBA32I',
'GL_RGB32I', 'GL_RGBA16I', 'GL_RGB16I', 'GL_RGBA8I', 'GL_RGB8I',
'GL_RED_INTEGER', 'GL_GREEN_INTEGER', 'GL_BLUE_INTEGER', 'GL_ALPHA_INTEGER',
'GL_RGB_INTEGER', 'GL_RGBA_INTEGER', 'GL_BGR_INTEGER', 'GL_BGRA_INTEGER',
'GL_SAMPLER_1D_ARRAY', 'GL_SAMPLER_2D_ARRAY', 'GL_SAMPLER_1D_ARRAY_SHADOW',
'GL_SAMPLER_2D_ARRAY_SHADOW', 'GL_SAMPLER_CUBE_SHADOW',
'GL_UNSIGNED_INT_VEC2', 'GL_UNSIGNED_INT_VEC3', 'GL_UNSIGNED_INT_VEC4',
'GL_INT_SAMPLER_1D', 'GL_INT_SAMPLER_2D', 'GL_INT_SAMPLER_3D',
'GL_INT_SAMPLER_CUBE', 'GL_INT_SAMPLER_1D_ARRAY', 'GL_INT_SAMPLER_2D_ARRAY',
'GL_UNSIGNED_INT_SAMPLER_1D', 'GL_UNSIGNED_INT_SAMPLER_2D',
'GL_UNSIGNED_INT_SAMPLER_3D', 'GL_UNSIGNED_INT_SAMPLER_CUBE',
'GL_UNSIGNED_INT_SAMPLER_1D_ARRAY', 'GL_UNSIGNED_INT_SAMPLER_2D_ARRAY',
'GL_QUERY_WAIT', 'GL_QUERY_NO_WAIT', 'GL_QUERY_BY_REGION_WAIT',
'GL_QUERY_BY_REGION_NO_WAIT', 'GL_TRANSPOSE_MODELVIEW_MATRIX_ARB',
'GL_TRANSPOSE_PROJECTION_MATRIX_ARB', 'GL_TRANSPOSE_TEXTURE_MATRIX_ARB',
'GL_TRANSPOSE_COLOR_MATRIX_ARB', 'GL_MULTISAMPLE_ARB',
'GL_SAMPLE_ALPHA_TO_COVERAGE_ARB', 'GL_SAMPLE_ALPHA_TO_ONE_ARB',
'GL_SAMPLE_COVERAGE_ARB', 'GL_SAMPLE_BUFFERS_ARB', 'GL_SAMPLES_ARB',
'GL_SAMPLE_COVERAGE_VALUE_ARB', 'GL_SAMPLE_COVERAGE_INVERT_ARB',
'GL_MULTISAMPLE_BIT_ARB', 'GL_NORMAL_MAP_ARB', 'GL_REFLECTION_MAP_ARB',
'GL_TEXTURE_CUBE_MAP_ARB', 'GL_TEXTURE_BINDING_CUBE_MAP_ARB',
'GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB',
'GL_PROXY_TEXTURE_CUBE_MAP_ARB', 'GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB',
'GL_COMPRESSED_ALPHA_ARB', 'GL_COMPRESSED_LUMINANCE_ARB',
'GL_COMPRESSED_LUMINANCE_ALPHA_ARB', 'GL_COMPRESSED_INTENSITY_ARB',
'GL_COMPRESSED_RGB_ARB', 'GL_COMPRESSED_RGBA_ARB',
'GL_TEXTURE_COMPRESSION_HINT_ARB', 'GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB',
'GL_TEXTURE_COMPRESSED_ARB', 'GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB',
'GL_COMPRESSED_TEXTURE_FORMATS_ARB', 'GL_CLAMP_TO_BORDER_ARB',
'GL_POINT_SIZE_MIN_ARB', 'GL_POINT_SIZE_MAX_ARB',
'GL_POINT_FADE_THRESHOLD_SIZE_ARB', 'GL_POINT_DISTANCE_ATTENUATION_ARB',
'GL_MAX_VERTEX_UNITS_ARB', 'GL_ACTIVE_VERTEX_UNITS_ARB',
'GL_WEIGHT_SUM_UNITY_ARB', 'GL_VERTEX_BLEND_ARB', 'GL_CURRENT_WEIGHT_ARB',
'GL_WEIGHT_ARRAY_TYPE_ARB', 'GL_WEIGHT_ARRAY_STRIDE_ARB',
'GL_WEIGHT_ARRAY_SIZE_ARB', 'GL_WEIGHT_ARRAY_POINTER_ARB',
'GL_WEIGHT_ARRAY_ARB', 'GL_MODELVIEW0_ARB', 'GL_MODELVIEW1_ARB',
'GL_MODELVIEW2_ARB', 'GL_MODELVIEW3_ARB', 'GL_MODELVIEW4_ARB',
'GL_MODELVIEW5_ARB', 'GL_MODELVIEW6_ARB', 'GL_MODELVIEW7_ARB',
'GL_MODELVIEW8_ARB', 'GL_MODELVIEW9_ARB', 'GL_MODELVIEW10_ARB',
'GL_MODELVIEW11_ARB', 'GL_MODELVIEW12_ARB', 'GL_MODELVIEW13_ARB',
'GL_MODELVIEW14_ARB', 'GL_MODELVIEW15_ARB', 'GL_MODELVIEW16_ARB',
'GL_MODELVIEW17_ARB', 'GL_MODELVIEW18_ARB', 'GL_MODELVIEW19_ARB',
'GL_MODELVIEW20_ARB', 'GL_MODELVIEW21_ARB', 'GL_MODELVIEW22_ARB',
'GL_MODELVIEW23_ARB', 'GL_MODELVIEW24_ARB', 'GL_MODELVIEW25_ARB',
'GL_MODELVIEW26_ARB', 'GL_MODELVIEW27_ARB', 'GL_MODELVIEW28_ARB',
'GL_MODELVIEW29_ARB', 'GL_MODELVIEW30_ARB', 'GL_MODELVIEW31_ARB',
'GL_MATRIX_PALETTE_ARB', 'GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB',
'GL_MAX_PALETTE_MATRICES_ARB', 'GL_CURRENT_PALETTE_MATRIX_ARB',
'GL_MATRIX_INDEX_ARRAY_ARB', 'GL_CURRENT_MATRIX_INDEX_ARB',
'GL_MATRIX_INDEX_ARRAY_SIZE_ARB', 'GL_MATRIX_INDEX_ARRAY_TYPE_ARB',
'GL_MATRIX_INDEX_ARRAY_STRIDE_ARB', 'GL_MATRIX_INDEX_ARRAY_POINTER_ARB',
'GL_COMBINE_ARB', 'GL_COMBINE_RGB_ARB', 'GL_COMBINE_ALPHA_ARB',
'GL_SOURCE0_RGB_ARB', 'GL_SOURCE1_RGB_ARB', 'GL_SOURCE2_RGB_ARB',
'GL_SOURCE0_ALPHA_ARB', 'GL_SOURCE1_ALPHA_ARB', 'GL_SOURCE2_ALPHA_ARB',
'GL_OPERAND0_RGB_ARB', 'GL_OPERAND1_RGB_ARB', 'GL_OPERAND2_RGB_ARB',
'GL_OPERAND0_ALPHA_ARB', 'GL_OPERAND1_ALPHA_ARB', 'GL_OPERAND2_ALPHA_ARB',
'GL_RGB_SCALE_ARB', 'GL_ADD_SIGNED_ARB', 'GL_INTERPOLATE_ARB',
'GL_SUBTRACT_ARB', 'GL_CONSTANT_ARB', 'GL_PRIMARY_COLOR_ARB',
'GL_PREVIOUS_ARB', 'GL_DOT3_RGB_ARB', 'GL_DOT3_RGBA_ARB',
'GL_MIRRORED_REPEAT_ARB', 'GL_DEPTH_COMPONENT16_ARB',
'GL_DEPTH_COMPONENT24_ARB', 'GL_DEPTH_COMPONENT32_ARB',
'GL_TEXTURE_DEPTH_SIZE_ARB', 'GL_DEPTH_TEXTURE_MODE_ARB',
'GL_TEXTURE_COMPARE_MODE_ARB', 'GL_TEXTURE_COMPARE_FUNC_ARB',
'GL_COMPARE_R_TO_TEXTURE_ARB', 'GL_TEXTURE_COMPARE_FAIL_VALUE_ARB',
'GL_COLOR_SUM_ARB', 'GL_VERTEX_PROGRAM_ARB',
'GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB', 'GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB',
'GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB', 'GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB',
'GL_CURRENT_VERTEX_ATTRIB_ARB', 'GL_PROGRAM_LENGTH_ARB',
'GL_PROGRAM_STRING_ARB', 'GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB',
'GL_MAX_PROGRAM_MATRICES_ARB', 'GL_CURRENT_MATRIX_STACK_DEPTH_ARB',
'GL_CURRENT_MATRIX_ARB', 'GL_VERTEX_PROGRAM_POINT_SIZE_ARB',
'GL_VERTEX_PROGRAM_TWO_SIDE_ARB', 'GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB',
'GL_PROGRAM_ERROR_POSITION_ARB', 'GL_PROGRAM_BINDING_ARB',
'GL_MAX_VERTEX_ATTRIBS_ARB', 'GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB',
'GL_PROGRAM_ERROR_STRING_ARB', 'GL_PROGRAM_FORMAT_ASCII_ARB',
'GL_PROGRAM_FORMAT_ARB', 'GL_PROGRAM_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_INSTRUCTIONS_ARB', 'GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB', 'GL_PROGRAM_TEMPORARIES_ARB',
'GL_MAX_PROGRAM_TEMPORARIES_ARB', 'GL_PROGRAM_NATIVE_TEMPORARIES_ARB',
'GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB', 'GL_PROGRAM_PARAMETERS_ARB',
'GL_MAX_PROGRAM_PARAMETERS_ARB', 'GL_PROGRAM_NATIVE_PARAMETERS_ARB',
'GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB', 'GL_PROGRAM_ATTRIBS_ARB',
'GL_MAX_PROGRAM_ATTRIBS_ARB', 'GL_PROGRAM_NATIVE_ATTRIBS_ARB',
'GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB', 'GL_PROGRAM_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB',
'GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB', 'GL_MAX_PROGRAM_ENV_PARAMETERS_ARB',
'GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB', 'GL_TRANSPOSE_CURRENT_MATRIX_ARB',
'GL_MATRIX0_ARB', 'GL_MATRIX1_ARB', 'GL_MATRIX2_ARB', 'GL_MATRIX3_ARB',
'GL_MATRIX4_ARB', 'GL_MATRIX5_ARB', 'GL_MATRIX6_ARB', 'GL_MATRIX7_ARB',
'GL_MATRIX8_ARB', 'GL_MATRIX9_ARB', 'GL_MATRIX10_ARB', 'GL_MATRIX11_ARB',
'GL_MATRIX12_ARB', 'GL_MATRIX13_ARB', 'GL_MATRIX14_ARB', 'GL_MATRIX15_ARB',
'GL_MATRIX16_ARB', 'GL_MATRIX17_ARB', 'GL_MATRIX18_ARB', 'GL_MATRIX19_ARB',
'GL_MATRIX20_ARB', 'GL_MATRIX21_ARB', 'GL_MATRIX22_ARB', 'GL_MATRIX23_ARB',
'GL_MATRIX24_ARB', 'GL_MATRIX25_ARB', 'GL_MATRIX26_ARB', 'GL_MATRIX27_ARB',
'GL_MATRIX28_ARB', 'GL_MATRIX29_ARB', 'GL_MATRIX30_ARB', 'GL_MATRIX31_ARB',
'GL_FRAGMENT_PROGRAM_ARB', 'GL_PROGRAM_ALU_INSTRUCTIONS_ARB',
'GL_PROGRAM_TEX_INSTRUCTIONS_ARB', 'GL_PROGRAM_TEX_INDIRECTIONS_ARB',
'GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',
'GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',
'GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB',
'GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB', 'GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB', 'GL_MAX_TEXTURE_COORDS_ARB',
'GL_MAX_TEXTURE_IMAGE_UNITS_ARB', 'GL_BUFFER_SIZE_ARB', 'GL_BUFFER_USAGE_ARB',
'GL_ARRAY_BUFFER_ARB', 'GL_ELEMENT_ARRAY_BUFFER_ARB',
'GL_ARRAY_BUFFER_BINDING_ARB', 'GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB',
'GL_VERTEX_ARRAY_BUFFER_BINDING_ARB', 'GL_NORMAL_ARRAY_BUFFER_BINDING_ARB',
'GL_COLOR_ARRAY_BUFFER_BINDING_ARB', 'GL_INDEX_ARRAY_BUFFER_BINDING_ARB',
'GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB',
'GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB',
'GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB',
'GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB',
'GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB',
'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB', 'GL_READ_ONLY_ARB',
'GL_WRITE_ONLY_ARB', 'GL_READ_WRITE_ARB', 'GL_BUFFER_ACCESS_ARB',
'GL_BUFFER_MAPPED_ARB', 'GL_BUFFER_MAP_POINTER_ARB', 'GL_STREAM_DRAW_ARB',
'GL_STREAM_READ_ARB', 'GL_STREAM_COPY_ARB', 'GL_STATIC_DRAW_ARB',
'GL_STATIC_READ_ARB', 'GL_STATIC_COPY_ARB', 'GL_DYNAMIC_DRAW_ARB',
'GL_DYNAMIC_READ_ARB', 'GL_DYNAMIC_COPY_ARB', 'GL_QUERY_COUNTER_BITS_ARB',
'GL_CURRENT_QUERY_ARB', 'GL_QUERY_RESULT_ARB',
'GL_QUERY_RESULT_AVAILABLE_ARB', 'GL_SAMPLES_PASSED_ARB',
'GL_PROGRAM_OBJECT_ARB', 'GL_SHADER_OBJECT_ARB', 'GL_OBJECT_TYPE_ARB',
'GL_OBJECT_SUBTYPE_ARB', 'GL_FLOAT_VEC2_ARB', 'GL_FLOAT_VEC3_ARB',
'GL_FLOAT_VEC4_ARB', 'GL_INT_VEC2_ARB', 'GL_INT_VEC3_ARB', 'GL_INT_VEC4_ARB',
'GL_BOOL_ARB', 'GL_BOOL_VEC2_ARB', 'GL_BOOL_VEC3_ARB', 'GL_BOOL_VEC4_ARB',
'GL_FLOAT_MAT2_ARB', 'GL_FLOAT_MAT3_ARB', 'GL_FLOAT_MAT4_ARB',
'GL_SAMPLER_1D_ARB', 'GL_SAMPLER_2D_ARB', 'GL_SAMPLER_3D_ARB',
'GL_SAMPLER_CUBE_ARB', 'GL_SAMPLER_1D_SHADOW_ARB', 'GL_SAMPLER_2D_SHADOW_ARB',
'GL_SAMPLER_2D_RECT_ARB', 'GL_SAMPLER_2D_RECT_SHADOW_ARB',
'GL_OBJECT_DELETE_STATUS_ARB', 'GL_OBJECT_COMPILE_STATUS_ARB',
'GL_OBJECT_LINK_STATUS_ARB', 'GL_OBJECT_VALIDATE_STATUS_ARB',
'GL_OBJECT_INFO_LOG_LENGTH_ARB', 'GL_OBJECT_ATTACHED_OBJECTS_ARB',
'GL_OBJECT_ACTIVE_UNIFORMS_ARB', 'GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB',
'GL_OBJECT_SHADER_SOURCE_LENGTH_ARB', 'GL_VERTEX_SHADER_ARB',
'GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB', 'GL_MAX_VARYING_FLOATS_ARB',
'GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB',
'GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB', 'GL_OBJECT_ACTIVE_ATTRIBUTES_ARB',
'GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB', 'GL_FRAGMENT_SHADER_ARB',
'GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB',
'GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB', 'GL_SHADING_LANGUAGE_VERSION_ARB',
'GL_POINT_SPRITE_ARB', 'GL_COORD_REPLACE_ARB', 'GL_MAX_DRAW_BUFFERS_ARB',
'GL_DRAW_BUFFER0_ARB', 'GL_DRAW_BUFFER1_ARB', 'GL_DRAW_BUFFER2_ARB',
'GL_DRAW_BUFFER3_ARB', 'GL_DRAW_BUFFER4_ARB', 'GL_DRAW_BUFFER5_ARB',
'GL_DRAW_BUFFER6_ARB', 'GL_DRAW_BUFFER7_ARB', 'GL_DRAW_BUFFER8_ARB',
'GL_DRAW_BUFFER9_ARB', 'GL_DRAW_BUFFER10_ARB', 'GL_DRAW_BUFFER11_ARB',
'GL_DRAW_BUFFER12_ARB', 'GL_DRAW_BUFFER13_ARB', 'GL_DRAW_BUFFER14_ARB',
'GL_DRAW_BUFFER15_ARB', 'GL_TEXTURE_RECTANGLE_ARB',
'GL_TEXTURE_BINDING_RECTANGLE_ARB', 'GL_PROXY_TEXTURE_RECTANGLE_ARB',
'GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB', 'GL_RGBA_FLOAT_MODE_ARB',
'GL_CLAMP_VERTEX_COLOR_ARB', 'GL_CLAMP_FRAGMENT_COLOR_ARB',
'GL_CLAMP_READ_COLOR_ARB', 'GL_FIXED_ONLY_ARB', 'GL_HALF_FLOAT_ARB',
'GL_TEXTURE_RED_TYPE_ARB', 'GL_TEXTURE_GREEN_TYPE_ARB',
'GL_TEXTURE_BLUE_TYPE_ARB', 'GL_TEXTURE_ALPHA_TYPE_ARB',
'GL_TEXTURE_LUMINANCE_TYPE_ARB', 'GL_TEXTURE_INTENSITY_TYPE_ARB',
'GL_TEXTURE_DEPTH_TYPE_ARB', 'GL_UNSIGNED_NORMALIZED_ARB', 'GL_RGBA32F_ARB',
'GL_RGB32F_ARB', 'GL_ALPHA32F_ARB', 'GL_INTENSITY32F_ARB',
'GL_LUMINANCE32F_ARB', 'GL_LUMINANCE_ALPHA32F_ARB', 'GL_RGBA16F_ARB',
'GL_RGB16F_ARB', 'GL_ALPHA16F_ARB', 'GL_INTENSITY16F_ARB',
'GL_LUMINANCE16F_ARB', 'GL_LUMINANCE_ALPHA16F_ARB',
'GL_PIXEL_PACK_BUFFER_ARB', 'GL_PIXEL_UNPACK_BUFFER_ARB',
'GL_PIXEL_PACK_BUFFER_BINDING_ARB', 'GL_PIXEL_UNPACK_BUFFER_BINDING_ARB',
'GL_DEPTH_COMPONENT32F', 'GL_DEPTH32F_STENCIL8',
'GL_FLOAT_32_UNSIGNED_INT_24_8_REV', 'GL_INVALID_FRAMEBUFFER_OPERATION',
'GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING',
'GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE',
'GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE', 'GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE', 'GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE', 'GL_FRAMEBUFFER_DEFAULT',
'GL_FRAMEBUFFER_UNDEFINED', 'GL_DEPTH_STENCIL_ATTACHMENT', 'GL_INDEX',
'GL_MAX_RENDERBUFFER_SIZE', 'GL_DEPTH_STENCIL', 'GL_UNSIGNED_INT_24_8',
'GL_DEPTH24_STENCIL8', 'GL_TEXTURE_STENCIL_SIZE', 'GL_FRAMEBUFFER_BINDING',
'GL_DRAW_FRAMEBUFFER_BINDING', 'GL_RENDERBUFFER_BINDING',
'GL_READ_FRAMEBUFFER', 'GL_DRAW_FRAMEBUFFER', 'GL_READ_FRAMEBUFFER_BINDING',
'GL_RENDERBUFFER_SAMPLES', 'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER', 'GL_FRAMEBUFFER_COMPLETE',
'GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT',
'GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',
'GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER',
'GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER', 'GL_FRAMEBUFFER_UNSUPPORTED',
'GL_MAX_COLOR_ATTACHMENTS', 'GL_COLOR_ATTACHMENT0', 'GL_COLOR_ATTACHMENT1',
'GL_COLOR_ATTACHMENT2', 'GL_COLOR_ATTACHMENT3', 'GL_COLOR_ATTACHMENT4',
'GL_COLOR_ATTACHMENT5', 'GL_COLOR_ATTACHMENT6', 'GL_COLOR_ATTACHMENT7',
'GL_COLOR_ATTACHMENT8', 'GL_COLOR_ATTACHMENT9', 'GL_COLOR_ATTACHMENT10',
'GL_COLOR_ATTACHMENT11', 'GL_COLOR_ATTACHMENT12', 'GL_COLOR_ATTACHMENT13',
'GL_COLOR_ATTACHMENT14', 'GL_COLOR_ATTACHMENT15', 'GL_DEPTH_ATTACHMENT',
'GL_STENCIL_ATTACHMENT', 'GL_FRAMEBUFFER', 'GL_RENDERBUFFER',
'GL_RENDERBUFFER_WIDTH', 'GL_RENDERBUFFER_HEIGHT',
'GL_RENDERBUFFER_INTERNAL_FORMAT', 'GL_STENCIL_INDEX1', 'GL_STENCIL_INDEX4',
'GL_STENCIL_INDEX8', 'GL_STENCIL_INDEX16', 'GL_RENDERBUFFER_RED_SIZE',
'GL_RENDERBUFFER_GREEN_SIZE', 'GL_RENDERBUFFER_BLUE_SIZE',
'GL_RENDERBUFFER_ALPHA_SIZE', 'GL_RENDERBUFFER_DEPTH_SIZE',
'GL_RENDERBUFFER_STENCIL_SIZE', 'GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE',
'GL_MAX_SAMPLES', 'GL_FRAMEBUFFER_SRGB', 'GL_LINES_ADJACENCY_ARB',
'GL_LINE_STRIP_ADJACENCY_ARB', 'GL_TRIANGLES_ADJACENCY_ARB',
'GL_TRIANGLE_STRIP_ADJACENCY_ARB', 'GL_PROGRAM_POINT_SIZE_ARB',
'GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB',
'GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB', 'GL_GEOMETRY_SHADER_ARB',
'GL_GEOMETRY_VERTICES_OUT_ARB', 'GL_GEOMETRY_INPUT_TYPE_ARB',
'GL_GEOMETRY_OUTPUT_TYPE_ARB', 'GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB',
'GL_MAX_VERTEX_VARYING_COMPONENTS_ARB',
'GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB',
'GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB',
'GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB', 'GL_HALF_FLOAT',
'GL_MAP_READ_BIT', 'GL_MAP_WRITE_BIT', 'GL_MAP_INVALIDATE_RANGE_BIT',
'GL_MAP_INVALIDATE_BUFFER_BIT', 'GL_MAP_FLUSH_EXPLICIT_BIT',
'GL_MAP_UNSYNCHRONIZED_BIT', 'GL_TEXTURE_BUFFER_ARB',
'GL_MAX_TEXTURE_BUFFER_SIZE_ARB', 'GL_TEXTURE_BINDING_BUFFER_ARB',
'GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB', 'GL_TEXTURE_BUFFER_FORMAT_ARB',
'GL_COMPRESSED_RED_RGTC1', 'GL_COMPRESSED_SIGNED_RED_RGTC1',
'GL_COMPRESSED_RG_RGTC2', 'GL_COMPRESSED_SIGNED_RG_RGTC2', 'GL_RG',
'GL_RG_INTEGER', 'GL_R8', 'GL_R16', 'GL_RG8', 'GL_RG16', 'GL_R16F', 'GL_R32F',
'GL_RG16F', 'GL_RG32F', 'GL_R8I', 'GL_R8UI', 'GL_R16I', 'GL_R16UI', 'GL_R32I',
'GL_R32UI', 'GL_RG8I', 'GL_RG8UI', 'GL_RG16I', 'GL_RG16UI', 'GL_RG32I',
'GL_RG32UI', 'GL_VERTEX_ARRAY_BINDING', 'GL_ABGR_EXT',
'GL_CONSTANT_COLOR_EXT', 'GL_ONE_MINUS_CONSTANT_COLOR_EXT',
'GL_CONSTANT_ALPHA_EXT', 'GL_ONE_MINUS_CONSTANT_ALPHA_EXT',
'GL_BLEND_COLOR_EXT', 'GL_POLYGON_OFFSET_EXT', 'GL_POLYGON_OFFSET_FACTOR_EXT',
'GL_POLYGON_OFFSET_BIAS_EXT', 'GL_ALPHA4_EXT', 'GL_ALPHA8_EXT',
'GL_ALPHA12_EXT', 'GL_ALPHA16_EXT', 'GL_LUMINANCE4_EXT', 'GL_LUMINANCE8_EXT',
'GL_LUMINANCE12_EXT', 'GL_LUMINANCE16_EXT', 'GL_LUMINANCE4_ALPHA4_EXT',
'GL_LUMINANCE6_ALPHA2_EXT', 'GL_LUMINANCE8_ALPHA8_EXT',
'GL_LUMINANCE12_ALPHA4_EXT', 'GL_LUMINANCE12_ALPHA12_EXT',
'GL_LUMINANCE16_ALPHA16_EXT', 'GL_INTENSITY_EXT', 'GL_INTENSITY4_EXT',
'GL_INTENSITY8_EXT', 'GL_INTENSITY12_EXT', 'GL_INTENSITY16_EXT',
'GL_RGB2_EXT', 'GL_RGB4_EXT', 'GL_RGB5_EXT', 'GL_RGB8_EXT', 'GL_RGB10_EXT',
'GL_RGB12_EXT', 'GL_RGB16_EXT', 'GL_RGBA2_EXT', 'GL_RGBA4_EXT',
'GL_RGB5_A1_EXT', 'GL_RGBA8_EXT', 'GL_RGB10_A2_EXT', 'GL_RGBA12_EXT',
'GL_RGBA16_EXT', 'GL_TEXTURE_RED_SIZE_EXT', 'GL_TEXTURE_GREEN_SIZE_EXT',
'GL_TEXTURE_BLUE_SIZE_EXT', 'GL_TEXTURE_ALPHA_SIZE_EXT',
'GL_TEXTURE_LUMINANCE_SIZE_EXT', 'GL_TEXTURE_INTENSITY_SIZE_EXT',
'GL_REPLACE_EXT', 'GL_PROXY_TEXTURE_1D_EXT', 'GL_PROXY_TEXTURE_2D_EXT',
'GL_TEXTURE_TOO_LARGE_EXT', 'GL_PACK_SKIP_IMAGES_EXT',
'GL_PACK_IMAGE_HEIGHT_EXT', 'GL_UNPACK_SKIP_IMAGES_EXT',
'GL_UNPACK_IMAGE_HEIGHT_EXT', 'GL_TEXTURE_3D_EXT', 'GL_PROXY_TEXTURE_3D_EXT',
'GL_TEXTURE_DEPTH_EXT', 'GL_TEXTURE_WRAP_R_EXT', 'GL_MAX_3D_TEXTURE_SIZE_EXT',
'GL_FILTER4_SGIS', 'GL_TEXTURE_FILTER4_SIZE_SGIS', 'GL_HISTOGRAM_EXT',
'GL_PROXY_HISTOGRAM_EXT', 'GL_HISTOGRAM_WIDTH_EXT', 'GL_HISTOGRAM_FORMAT_EXT',
'GL_HISTOGRAM_RED_SIZE_EXT', 'GL_HISTOGRAM_GREEN_SIZE_EXT',
'GL_HISTOGRAM_BLUE_SIZE_EXT', 'GL_HISTOGRAM_ALPHA_SIZE_EXT',
'GL_HISTOGRAM_LUMINANCE_SIZE_EXT', 'GL_HISTOGRAM_SINK_EXT', 'GL_MINMAX_EXT',
'GL_MINMAX_FORMAT_EXT', 'GL_MINMAX_SINK_EXT', 'GL_TABLE_TOO_LARGE_EXT',
'GL_CONVOLUTION_1D_EXT', 'GL_CONVOLUTION_2D_EXT', 'GL_SEPARABLE_2D_EXT',
'GL_CONVOLUTION_BORDER_MODE_EXT', 'GL_CONVOLUTION_FILTER_SCALE_EXT',
'GL_CONVOLUTION_FILTER_BIAS_EXT', 'GL_REDUCE_EXT',
'GL_CONVOLUTION_FORMAT_EXT', 'GL_CONVOLUTION_WIDTH_EXT',
'GL_CONVOLUTION_HEIGHT_EXT', 'GL_MAX_CONVOLUTION_WIDTH_EXT',
'GL_MAX_CONVOLUTION_HEIGHT_EXT', 'GL_POST_CONVOLUTION_RED_SCALE_EXT',
'GL_POST_CONVOLUTION_GREEN_SCALE_EXT', 'GL_POST_CONVOLUTION_BLUE_SCALE_EXT',
'GL_POST_CONVOLUTION_ALPHA_SCALE_EXT', 'GL_POST_CONVOLUTION_RED_BIAS_EXT',
'GL_POST_CONVOLUTION_GREEN_BIAS_EXT', 'GL_POST_CONVOLUTION_BLUE_BIAS_EXT',
'GL_POST_CONVOLUTION_ALPHA_BIAS_EXT', 'GL_COLOR_MATRIX_SGI',
'GL_COLOR_MATRIX_STACK_DEPTH_SGI', 'GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI',
'GL_POST_COLOR_MATRIX_RED_SCALE_SGI', 'GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI',
'GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI', 'GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI',
'GL_POST_COLOR_MATRIX_RED_BIAS_SGI', 'GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI',
'GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI', 'GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI',
'GL_COLOR_TABLE_SGI', 'GL_POST_CONVOLUTION_COLOR_TABLE_SGI',
'GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI', 'GL_PROXY_COLOR_TABLE_SGI',
'GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI',
'GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI', 'GL_COLOR_TABLE_SCALE_SGI',
'GL_COLOR_TABLE_BIAS_SGI', 'GL_COLOR_TABLE_FORMAT_SGI',
'GL_COLOR_TABLE_WIDTH_SGI', 'GL_COLOR_TABLE_RED_SIZE_SGI',
'GL_COLOR_TABLE_GREEN_SIZE_SGI', 'GL_COLOR_TABLE_BLUE_SIZE_SGI',
'GL_COLOR_TABLE_ALPHA_SIZE_SGI', 'GL_COLOR_TABLE_LUMINANCE_SIZE_SGI',
'GL_COLOR_TABLE_INTENSITY_SIZE_SGI', 'GL_PIXEL_TEXTURE_SGIS',
'GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS', 'GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS',
'GL_PIXEL_GROUP_COLOR_SGIS', 'GL_PIXEL_TEX_GEN_SGIX',
'GL_PIXEL_TEX_GEN_MODE_SGIX', 'GL_PACK_SKIP_VOLUMES_SGIS',
'GL_PACK_IMAGE_DEPTH_SGIS', 'GL_UNPACK_SKIP_VOLUMES_SGIS',
'GL_UNPACK_IMAGE_DEPTH_SGIS', 'GL_TEXTURE_4D_SGIS',
'GL_PROXY_TEXTURE_4D_SGIS', 'GL_TEXTURE_4DSIZE_SGIS',
'GL_TEXTURE_WRAP_Q_SGIS', 'GL_MAX_4D_TEXTURE_SIZE_SGIS',
'GL_TEXTURE_4D_BINDING_SGIS', 'GL_TEXTURE_COLOR_TABLE_SGI',
'GL_PROXY_TEXTURE_COLOR_TABLE_SGI', 'GL_CMYK_EXT', 'GL_CMYKA_EXT',
'GL_PACK_CMYK_HINT_EXT', 'GL_UNPACK_CMYK_HINT_EXT', 'GL_TEXTURE_PRIORITY_EXT',
'GL_TEXTURE_RESIDENT_EXT', 'GL_TEXTURE_1D_BINDING_EXT',
'GL_TEXTURE_2D_BINDING_EXT', 'GL_TEXTURE_3D_BINDING_EXT',
'GL_DETAIL_TEXTURE_2D_SGIS', 'GL_DETAIL_TEXTURE_2D_BINDING_SGIS',
'GL_LINEAR_DETAIL_SGIS', 'GL_LINEAR_DETAIL_ALPHA_SGIS',
'GL_LINEAR_DETAIL_COLOR_SGIS', 'GL_DETAIL_TEXTURE_LEVEL_SGIS',
'GL_DETAIL_TEXTURE_MODE_SGIS', 'GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS',
'GL_LINEAR_SHARPEN_SGIS', 'GL_LINEAR_SHARPEN_ALPHA_SGIS',
'GL_LINEAR_SHARPEN_COLOR_SGIS', 'GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS',
'GL_UNSIGNED_BYTE_3_3_2_EXT', 'GL_UNSIGNED_SHORT_4_4_4_4_EXT',
'GL_UNSIGNED_SHORT_5_5_5_1_EXT', 'GL_UNSIGNED_INT_8_8_8_8_EXT',
'GL_UNSIGNED_INT_10_10_10_2_EXT', 'GL_TEXTURE_MIN_LOD_SGIS',
'GL_TEXTURE_MAX_LOD_SGIS', 'GL_TEXTURE_BASE_LEVEL_SGIS',
'GL_TEXTURE_MAX_LEVEL_SGIS', 'GL_MULTISAMPLE_SGIS',
'GL_SAMPLE_ALPHA_TO_MASK_SGIS', 'GL_SAMPLE_ALPHA_TO_ONE_SGIS',
'GL_SAMPLE_MASK_SGIS', 'GL_1PASS_SGIS', 'GL_2PASS_0_SGIS', 'GL_2PASS_1_SGIS',
'GL_4PASS_0_SGIS', 'GL_4PASS_1_SGIS', 'GL_4PASS_2_SGIS', 'GL_4PASS_3_SGIS',
'GL_SAMPLE_BUFFERS_SGIS', 'GL_SAMPLES_SGIS', 'GL_SAMPLE_MASK_VALUE_SGIS',
'GL_SAMPLE_MASK_INVERT_SGIS', 'GL_SAMPLE_PATTERN_SGIS',
'GL_RESCALE_NORMAL_EXT', 'GL_VERTEX_ARRAY_EXT', 'GL_NORMAL_ARRAY_EXT',
'GL_COLOR_ARRAY_EXT', 'GL_INDEX_ARRAY_EXT', 'GL_TEXTURE_COORD_ARRAY_EXT',
'GL_EDGE_FLAG_ARRAY_EXT', 'GL_VERTEX_ARRAY_SIZE_EXT',
'GL_VERTEX_ARRAY_TYPE_EXT', 'GL_VERTEX_ARRAY_STRIDE_EXT',
'GL_VERTEX_ARRAY_COUNT_EXT', 'GL_NORMAL_ARRAY_TYPE_EXT',
'GL_NORMAL_ARRAY_STRIDE_EXT', 'GL_NORMAL_ARRAY_COUNT_EXT',
'GL_COLOR_ARRAY_SIZE_EXT', 'GL_COLOR_ARRAY_TYPE_EXT',
'GL_COLOR_ARRAY_STRIDE_EXT', 'GL_COLOR_ARRAY_COUNT_EXT',
'GL_INDEX_ARRAY_TYPE_EXT', 'GL_INDEX_ARRAY_STRIDE_EXT',
'GL_INDEX_ARRAY_COUNT_EXT', 'GL_TEXTURE_COORD_ARRAY_SIZE_EXT',
'GL_TEXTURE_COORD_ARRAY_TYPE_EXT', 'GL_TEXTURE_COORD_ARRAY_STRIDE_EXT',
'GL_TEXTURE_COORD_ARRAY_COUNT_EXT', 'GL_EDGE_FLAG_ARRAY_STRIDE_EXT',
'GL_EDGE_FLAG_ARRAY_COUNT_EXT', 'GL_VERTEX_ARRAY_POINTER_EXT',
'GL_NORMAL_ARRAY_POINTER_EXT', 'GL_COLOR_ARRAY_POINTER_EXT',
'GL_INDEX_ARRAY_POINTER_EXT', 'GL_TEXTURE_COORD_ARRAY_POINTER_EXT',
'GL_EDGE_FLAG_ARRAY_POINTER_EXT', 'GL_GENERATE_MIPMAP_SGIS',
'GL_GENERATE_MIPMAP_HINT_SGIS', 'GL_LINEAR_CLIPMAP_LINEAR_SGIX',
'GL_TEXTURE_CLIPMAP_CENTER_SGIX', 'GL_TEXTURE_CLIPMAP_FRAME_SGIX',
'GL_TEXTURE_CLIPMAP_OFFSET_SGIX', 'GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX',
'GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX', 'GL_TEXTURE_CLIPMAP_DEPTH_SGIX',
'GL_MAX_CLIPMAP_DEPTH_SGIX', 'GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX',
'GL_NEAREST_CLIPMAP_NEAREST_SGIX', 'GL_NEAREST_CLIPMAP_LINEAR_SGIX',
'GL_LINEAR_CLIPMAP_NEAREST_SGIX', 'GL_TEXTURE_COMPARE_SGIX',
'GL_TEXTURE_COMPARE_OPERATOR_SGIX', 'GL_TEXTURE_LEQUAL_R_SGIX',
'GL_TEXTURE_GEQUAL_R_SGIX', 'GL_CLAMP_TO_EDGE_SGIS',
'GL_CLAMP_TO_BORDER_SGIS', 'GL_FUNC_ADD_EXT', 'GL_MIN_EXT', 'GL_MAX_EXT',
'GL_BLEND_EQUATION_EXT', 'GL_FUNC_SUBTRACT_EXT',
'GL_FUNC_REVERSE_SUBTRACT_EXT', 'GL_INTERLACE_SGIX',
'GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX', 'GL_PIXEL_TILE_CACHE_INCREMENT_SGIX',
'GL_PIXEL_TILE_WIDTH_SGIX', 'GL_PIXEL_TILE_HEIGHT_SGIX',
'GL_PIXEL_TILE_GRID_WIDTH_SGIX', 'GL_PIXEL_TILE_GRID_HEIGHT_SGIX',
'GL_PIXEL_TILE_GRID_DEPTH_SGIX', 'GL_PIXEL_TILE_CACHE_SIZE_SGIX',
'GL_DUAL_ALPHA4_SGIS', 'GL_DUAL_ALPHA8_SGIS', 'GL_DUAL_ALPHA12_SGIS',
'GL_DUAL_ALPHA16_SGIS', 'GL_DUAL_LUMINANCE4_SGIS', 'GL_DUAL_LUMINANCE8_SGIS',
'GL_DUAL_LUMINANCE12_SGIS', 'GL_DUAL_LUMINANCE16_SGIS',
'GL_DUAL_INTENSITY4_SGIS', 'GL_DUAL_INTENSITY8_SGIS',
'GL_DUAL_INTENSITY12_SGIS', 'GL_DUAL_INTENSITY16_SGIS',
'GL_DUAL_LUMINANCE_ALPHA4_SGIS', 'GL_DUAL_LUMINANCE_ALPHA8_SGIS',
'GL_QUAD_ALPHA4_SGIS', 'GL_QUAD_ALPHA8_SGIS', 'GL_QUAD_LUMINANCE4_SGIS',
'GL_QUAD_LUMINANCE8_SGIS', 'GL_QUAD_INTENSITY4_SGIS',
'GL_QUAD_INTENSITY8_SGIS', 'GL_DUAL_TEXTURE_SELECT_SGIS',
'GL_QUAD_TEXTURE_SELECT_SGIS', 'GL_SPRITE_SGIX', 'GL_SPRITE_MODE_SGIX',
'GL_SPRITE_AXIS_SGIX', 'GL_SPRITE_TRANSLATION_SGIX', 'GL_SPRITE_AXIAL_SGIX',
'GL_SPRITE_OBJECT_ALIGNED_SGIX', 'GL_SPRITE_EYE_ALIGNED_SGIX',
'GL_TEXTURE_MULTI_BUFFER_HINT_SGIX', 'GL_POINT_SIZE_MIN_EXT',
'GL_POINT_SIZE_MAX_EXT', 'GL_POINT_FADE_THRESHOLD_SIZE_EXT',
'GL_DISTANCE_ATTENUATION_EXT', 'GL_POINT_SIZE_MIN_SGIS',
'GL_POINT_SIZE_MAX_SGIS', 'GL_POINT_FADE_THRESHOLD_SIZE_SGIS',
'GL_DISTANCE_ATTENUATION_SGIS', 'GL_INSTRUMENT_BUFFER_POINTER_SGIX',
'GL_INSTRUMENT_MEASUREMENTS_SGIX', 'GL_POST_TEXTURE_FILTER_BIAS_SGIX',
'GL_POST_TEXTURE_FILTER_SCALE_SGIX', 'GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX',
'GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX', 'GL_FRAMEZOOM_SGIX',
'GL_FRAMEZOOM_FACTOR_SGIX', 'GL_MAX_FRAMEZOOM_FACTOR_SGIX',
'GL_TEXTURE_DEFORMATION_BIT_SGIX', 'GL_GEOMETRY_DEFORMATION_BIT_SGIX',
'GL_GEOMETRY_DEFORMATION_SGIX', 'GL_TEXTURE_DEFORMATION_SGIX',
'GL_DEFORMATIONS_MASK_SGIX', 'GL_MAX_DEFORMATION_ORDER_SGIX',
'GL_REFERENCE_PLANE_SGIX', 'GL_REFERENCE_PLANE_EQUATION_SGIX',
'GL_DEPTH_COMPONENT16_SGIX', 'GL_DEPTH_COMPONENT24_SGIX',
'GL_DEPTH_COMPONENT32_SGIX', 'GL_FOG_FUNC_SGIS', 'GL_FOG_FUNC_POINTS_SGIS',
'GL_MAX_FOG_FUNC_POINTS_SGIS', 'GL_FOG_OFFSET_SGIX',
'GL_FOG_OFFSET_VALUE_SGIX', 'GL_IMAGE_SCALE_X_HP', 'GL_IMAGE_SCALE_Y_HP',
'GL_IMAGE_TRANSLATE_X_HP', 'GL_IMAGE_TRANSLATE_Y_HP',
'GL_IMAGE_ROTATE_ANGLE_HP', 'GL_IMAGE_ROTATE_ORIGIN_X_HP',
'GL_IMAGE_ROTATE_ORIGIN_Y_HP', 'GL_IMAGE_MAG_FILTER_HP',
'GL_IMAGE_MIN_FILTER_HP', 'GL_IMAGE_CUBIC_WEIGHT_HP', 'GL_CUBIC_HP',
'GL_AVERAGE_HP', 'GL_IMAGE_TRANSFORM_2D_HP',
'GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP',
'GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP', 'GL_IGNORE_BORDER_HP',
'GL_CONSTANT_BORDER_HP', 'GL_REPLICATE_BORDER_HP',
'GL_CONVOLUTION_BORDER_COLOR_HP', 'GL_TEXTURE_ENV_BIAS_SGIX',
'GL_VERTEX_DATA_HINT_PGI', 'GL_VERTEX_CONSISTENT_HINT_PGI',
'GL_MATERIAL_SIDE_HINT_PGI', 'GL_MAX_VERTEX_HINT_PGI', 'GL_COLOR3_BIT_PGI',
'GL_COLOR4_BIT_PGI', 'GL_EDGEFLAG_BIT_PGI', 'GL_INDEX_BIT_PGI',
'GL_MAT_AMBIENT_BIT_PGI', 'GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI',
'GL_MAT_DIFFUSE_BIT_PGI', 'GL_MAT_EMISSION_BIT_PGI',
'GL_MAT_COLOR_INDEXES_BIT_PGI', 'GL_MAT_SHININESS_BIT_PGI',
'GL_MAT_SPECULAR_BIT_PGI', 'GL_NORMAL_BIT_PGI', 'GL_TEXCOORD1_BIT_PGI',
'GL_TEXCOORD2_BIT_PGI', 'GL_TEXCOORD3_BIT_PGI', 'GL_TEXCOORD4_BIT_PGI',
'GL_VERTEX23_BIT_PGI', 'GL_VERTEX4_BIT_PGI',
'GL_PREFER_DOUBLEBUFFER_HINT_PGI', 'GL_CONSERVE_MEMORY_HINT_PGI',
'GL_RECLAIM_MEMORY_HINT_PGI', 'GL_NATIVE_GRAPHICS_HANDLE_PGI',
'GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI', 'GL_NATIVE_GRAPHICS_END_HINT_PGI',
'GL_ALWAYS_FAST_HINT_PGI', 'GL_ALWAYS_SOFT_HINT_PGI',
'GL_ALLOW_DRAW_OBJ_HINT_PGI', 'GL_ALLOW_DRAW_WIN_HINT_PGI',
'GL_ALLOW_DRAW_FRG_HINT_PGI', 'GL_ALLOW_DRAW_MEM_HINT_PGI',
'GL_STRICT_DEPTHFUNC_HINT_PGI', 'GL_STRICT_LIGHTING_HINT_PGI',
'GL_STRICT_SCISSOR_HINT_PGI', 'GL_FULL_STIPPLE_HINT_PGI',
'GL_CLIP_NEAR_HINT_PGI', 'GL_CLIP_FAR_HINT_PGI', 'GL_WIDE_LINE_HINT_PGI',
'GL_BACK_NORMALS_HINT_PGI', 'GL_COLOR_INDEX1_EXT', 'GL_COLOR_INDEX2_EXT',
'GL_COLOR_INDEX4_EXT', 'GL_COLOR_INDEX8_EXT', 'GL_COLOR_INDEX12_EXT',
'GL_COLOR_INDEX16_EXT', 'GL_TEXTURE_INDEX_SIZE_EXT',
'GL_CLIP_VOLUME_CLIPPING_HINT_EXT', 'GL_LIST_PRIORITY_SGIX',
'GL_IR_INSTRUMENT1_SGIX', 'GL_CALLIGRAPHIC_FRAGMENT_SGIX',
'GL_TEXTURE_LOD_BIAS_S_SGIX', 'GL_TEXTURE_LOD_BIAS_T_SGIX',
'GL_TEXTURE_LOD_BIAS_R_SGIX', 'GL_SHADOW_AMBIENT_SGIX',
'GL_INDEX_MATERIAL_EXT', 'GL_INDEX_MATERIAL_PARAMETER_EXT',
'GL_INDEX_MATERIAL_FACE_EXT', 'GL_INDEX_TEST_EXT', 'GL_INDEX_TEST_FUNC_EXT',
'GL_INDEX_TEST_REF_EXT', 'GL_IUI_V2F_EXT', 'GL_IUI_V3F_EXT',
'GL_IUI_N3F_V2F_EXT', 'GL_IUI_N3F_V3F_EXT', 'GL_T2F_IUI_V2F_EXT',
'GL_T2F_IUI_V3F_EXT', 'GL_T2F_IUI_N3F_V2F_EXT', 'GL_T2F_IUI_N3F_V3F_EXT',
'GL_ARRAY_ELEMENT_LOCK_FIRST_EXT', 'GL_ARRAY_ELEMENT_LOCK_COUNT_EXT',
'GL_CULL_VERTEX_EXT', 'GL_CULL_VERTEX_EYE_POSITION_EXT',
'GL_CULL_VERTEX_OBJECT_POSITION_EXT', 'GL_YCRCB_422_SGIX',
'GL_YCRCB_444_SGIX', 'GL_FRAGMENT_LIGHTING_SGIX',
'GL_FRAGMENT_COLOR_MATERIAL_SGIX', 'GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX',
'GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX', 'GL_MAX_FRAGMENT_LIGHTS_SGIX',
'GL_MAX_ACTIVE_LIGHTS_SGIX', 'GL_CURRENT_RASTER_NORMAL_SGIX',
'GL_LIGHT_ENV_MODE_SGIX', 'GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX',
'GL_FRAGMENT_LIGHT0_SGIX', 'GL_FRAGMENT_LIGHT1_SGIX',
'GL_FRAGMENT_LIGHT2_SGIX', 'GL_FRAGMENT_LIGHT3_SGIX',
'GL_FRAGMENT_LIGHT4_SGIX', 'GL_FRAGMENT_LIGHT5_SGIX',
'GL_FRAGMENT_LIGHT6_SGIX', 'GL_FRAGMENT_LIGHT7_SGIX',
'GL_RASTER_POSITION_UNCLIPPED_IBM', 'GL_TEXTURE_LIGHTING_MODE_HP',
'GL_TEXTURE_POST_SPECULAR_HP', 'GL_TEXTURE_PRE_SPECULAR_HP',
'GL_MAX_ELEMENTS_VERTICES_EXT', 'GL_MAX_ELEMENTS_INDICES_EXT', 'GL_PHONG_WIN',
'GL_PHONG_HINT_WIN', 'GL_FOG_SPECULAR_TEXTURE_WIN',
'GL_FRAGMENT_MATERIAL_EXT', 'GL_FRAGMENT_NORMAL_EXT', 'GL_FRAGMENT_COLOR_EXT',
'GL_ATTENUATION_EXT', 'GL_SHADOW_ATTENUATION_EXT',
'GL_TEXTURE_APPLICATION_MODE_EXT', 'GL_TEXTURE_LIGHT_EXT',
'GL_TEXTURE_MATERIAL_FACE_EXT', 'GL_TEXTURE_MATERIAL_PARAMETER_EXT',
'GL_ALPHA_MIN_SGIX', 'GL_ALPHA_MAX_SGIX', 'GL_PIXEL_TEX_GEN_Q_CEILING_SGIX',
'GL_PIXEL_TEX_GEN_Q_ROUND_SGIX', 'GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX', 'GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX', 'GL_BGR_EXT', 'GL_BGRA_EXT',
'GL_ASYNC_MARKER_SGIX', 'GL_ASYNC_TEX_IMAGE_SGIX',
'GL_ASYNC_DRAW_PIXELS_SGIX', 'GL_ASYNC_READ_PIXELS_SGIX',
'GL_MAX_ASYNC_TEX_IMAGE_SGIX', 'GL_MAX_ASYNC_DRAW_PIXELS_SGIX',
'GL_MAX_ASYNC_READ_PIXELS_SGIX', 'GL_ASYNC_HISTOGRAM_SGIX',
'GL_MAX_ASYNC_HISTOGRAM_SGIX', 'GL_PARALLEL_ARRAYS_INTEL',
'GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL', 'GL_OCCLUSION_TEST_HP',
'GL_OCCLUSION_TEST_RESULT_HP', 'GL_PIXEL_TRANSFORM_2D_EXT',
'GL_PIXEL_MAG_FILTER_EXT', 'GL_PIXEL_MIN_FILTER_EXT',
'GL_PIXEL_CUBIC_WEIGHT_EXT', 'GL_CUBIC_EXT', 'GL_AVERAGE_EXT',
'GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',
'GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',
'GL_PIXEL_TRANSFORM_2D_MATRIX_EXT', 'GL_SHARED_TEXTURE_PALETTE_EXT',
'GL_LIGHT_MODEL_COLOR_CONTROL_EXT', 'GL_SINGLE_COLOR_EXT',
'GL_SEPARATE_SPECULAR_COLOR_EXT', 'GL_COLOR_SUM_EXT',
'GL_CURRENT_SECONDARY_COLOR_EXT', 'GL_SECONDARY_COLOR_ARRAY_SIZE_EXT',
'GL_SECONDARY_COLOR_ARRAY_TYPE_EXT', 'GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT',
'GL_SECONDARY_COLOR_ARRAY_POINTER_EXT', 'GL_SECONDARY_COLOR_ARRAY_EXT',
'GL_PERTURB_EXT', 'GL_TEXTURE_NORMAL_EXT', 'GL_FOG_COORDINATE_SOURCE_EXT',
'GL_FOG_COORDINATE_EXT', 'GL_FRAGMENT_DEPTH_EXT',
'GL_CURRENT_FOG_COORDINATE_EXT', 'GL_FOG_COORDINATE_ARRAY_TYPE_EXT',
'GL_FOG_COORDINATE_ARRAY_STRIDE_EXT', 'GL_FOG_COORDINATE_ARRAY_POINTER_EXT',
'GL_FOG_COORDINATE_ARRAY_EXT', 'GL_SCREEN_COORDINATES_REND',
'GL_INVERTED_SCREEN_W_REND', 'GL_TANGENT_ARRAY_EXT', 'GL_BINORMAL_ARRAY_EXT',
'GL_CURRENT_TANGENT_EXT', 'GL_CURRENT_BINORMAL_EXT',
'GL_TANGENT_ARRAY_TYPE_EXT', 'GL_TANGENT_ARRAY_STRIDE_EXT',
'GL_BINORMAL_ARRAY_TYPE_EXT', 'GL_BINORMAL_ARRAY_STRIDE_EXT',
'GL_TANGENT_ARRAY_POINTER_EXT', 'GL_BINORMAL_ARRAY_POINTER_EXT',
'GL_MAP1_TANGENT_EXT', 'GL_MAP2_TANGENT_EXT', 'GL_MAP1_BINORMAL_EXT',
'GL_MAP2_BINORMAL_EXT', 'GL_COMBINE_EXT', 'GL_COMBINE_RGB_EXT',
'GL_COMBINE_ALPHA_EXT', 'GL_RGB_SCALE_EXT', 'GL_ADD_SIGNED_EXT',
'GL_INTERPOLATE_EXT', 'GL_CONSTANT_EXT', 'GL_PRIMARY_COLOR_EXT',
'GL_PREVIOUS_EXT', 'GL_SOURCE0_RGB_EXT', 'GL_SOURCE1_RGB_EXT',
'GL_SOURCE2_RGB_EXT', 'GL_SOURCE0_ALPHA_EXT', 'GL_SOURCE1_ALPHA_EXT',
'GL_SOURCE2_ALPHA_EXT', 'GL_OPERAND0_RGB_EXT', 'GL_OPERAND1_RGB_EXT',
'GL_OPERAND2_RGB_EXT', 'GL_OPERAND0_ALPHA_EXT', 'GL_OPERAND1_ALPHA_EXT',
'GL_OPERAND2_ALPHA_EXT', 'GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE',
'GL_TRANSFORM_HINT_APPLE', 'GL_FOG_SCALE_SGIX', 'GL_FOG_SCALE_VALUE_SGIX',
'GL_UNPACK_CONSTANT_DATA_SUNX', 'GL_TEXTURE_CONSTANT_DATA_SUNX',
'GL_GLOBAL_ALPHA_SUN', 'GL_GLOBAL_ALPHA_FACTOR_SUN', 'GL_RESTART_SUN',
'GL_REPLACE_MIDDLE_SUN', 'GL_REPLACE_OLDEST_SUN', 'GL_TRIANGLE_LIST_SUN',
'GL_REPLACEMENT_CODE_SUN', 'GL_REPLACEMENT_CODE_ARRAY_SUN',
'GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN', 'GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN',
'GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN', 'GL_R1UI_V3F_SUN',
'GL_R1UI_C4UB_V3F_SUN', 'GL_R1UI_C3F_V3F_SUN', 'GL_R1UI_N3F_V3F_SUN',
'GL_R1UI_C4F_N3F_V3F_SUN', 'GL_R1UI_T2F_V3F_SUN', 'GL_R1UI_T2F_N3F_V3F_SUN',
'GL_R1UI_T2F_C4F_N3F_V3F_SUN', 'GL_BLEND_DST_RGB_EXT', 'GL_BLEND_SRC_RGB_EXT',
'GL_BLEND_DST_ALPHA_EXT', 'GL_BLEND_SRC_ALPHA_EXT', 'GL_RED_MIN_CLAMP_INGR',
'GL_GREEN_MIN_CLAMP_INGR', 'GL_BLUE_MIN_CLAMP_INGR',
'GL_ALPHA_MIN_CLAMP_INGR', 'GL_RED_MAX_CLAMP_INGR', 'GL_GREEN_MAX_CLAMP_INGR',
'GL_BLUE_MAX_CLAMP_INGR', 'GL_ALPHA_MAX_CLAMP_INGR', 'GL_INTERLACE_READ_INGR',
'GL_INCR_WRAP_EXT', 'GL_DECR_WRAP_EXT', 'GL_422_EXT', 'GL_422_REV_EXT',
'GL_422_AVERAGE_EXT', 'GL_422_REV_AVERAGE_EXT', 'GL_NORMAL_MAP_NV',
'GL_REFLECTION_MAP_NV', 'GL_NORMAL_MAP_EXT', 'GL_REFLECTION_MAP_EXT',
'GL_TEXTURE_CUBE_MAP_EXT', 'GL_TEXTURE_BINDING_CUBE_MAP_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT',
'GL_PROXY_TEXTURE_CUBE_MAP_EXT', 'GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT',
'GL_WRAP_BORDER_SUN', 'GL_MAX_TEXTURE_LOD_BIAS_EXT',
'GL_TEXTURE_FILTER_CONTROL_EXT', 'GL_TEXTURE_LOD_BIAS_EXT',
'GL_TEXTURE_MAX_ANISOTROPY_EXT', 'GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT',
'GL_MODELVIEW0_STACK_DEPTH_EXT', 'GL_MODELVIEW1_STACK_DEPTH_EXT',
'GL_MODELVIEW0_MATRIX_EXT', 'GL_MODELVIEW1_MATRIX_EXT',
'GL_VERTEX_WEIGHTING_EXT', 'GL_MODELVIEW0_EXT', 'GL_MODELVIEW1_EXT',
'GL_CURRENT_VERTEX_WEIGHT_EXT', 'GL_VERTEX_WEIGHT_ARRAY_EXT',
'GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT', 'GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT',
'GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT', 'GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT',
'GL_MAX_SHININESS_NV', 'GL_MAX_SPOT_EXPONENT_NV', 'GL_VERTEX_ARRAY_RANGE_NV',
'GL_VERTEX_ARRAY_RANGE_LENGTH_NV', 'GL_VERTEX_ARRAY_RANGE_VALID_NV',
'GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV', 'GL_VERTEX_ARRAY_RANGE_POINTER_NV',
'GL_REGISTER_COMBINERS_NV', 'GL_VARIABLE_A_NV', 'GL_VARIABLE_B_NV',
'GL_VARIABLE_C_NV', 'GL_VARIABLE_D_NV', 'GL_VARIABLE_E_NV',
'GL_VARIABLE_F_NV', 'GL_VARIABLE_G_NV', 'GL_CONSTANT_COLOR0_NV',
'GL_CONSTANT_COLOR1_NV', 'GL_PRIMARY_COLOR_NV', 'GL_SECONDARY_COLOR_NV',
'GL_SPARE0_NV', 'GL_SPARE1_NV', 'GL_DISCARD_NV', 'GL_E_TIMES_F_NV',
'GL_SPARE0_PLUS_SECONDARY_COLOR_NV', 'GL_UNSIGNED_IDENTITY_NV',
'GL_UNSIGNED_INVERT_NV', 'GL_EXPAND_NORMAL_NV', 'GL_EXPAND_NEGATE_NV',
'GL_HALF_BIAS_NORMAL_NV', 'GL_HALF_BIAS_NEGATE_NV', 'GL_SIGNED_IDENTITY_NV',
'GL_SIGNED_NEGATE_NV', 'GL_SCALE_BY_TWO_NV', 'GL_SCALE_BY_FOUR_NV',
'GL_SCALE_BY_ONE_HALF_NV', 'GL_BIAS_BY_NEGATIVE_ONE_HALF_NV',
'GL_COMBINER_INPUT_NV', 'GL_COMBINER_MAPPING_NV',
'GL_COMBINER_COMPONENT_USAGE_NV', 'GL_COMBINER_AB_DOT_PRODUCT_NV',
'GL_COMBINER_CD_DOT_PRODUCT_NV', 'GL_COMBINER_MUX_SUM_NV',
'GL_COMBINER_SCALE_NV', 'GL_COMBINER_BIAS_NV', 'GL_COMBINER_AB_OUTPUT_NV',
'GL_COMBINER_CD_OUTPUT_NV', 'GL_COMBINER_SUM_OUTPUT_NV',
'GL_MAX_GENERAL_COMBINERS_NV', 'GL_NUM_GENERAL_COMBINERS_NV',
'GL_COLOR_SUM_CLAMP_NV', 'GL_COMBINER0_NV', 'GL_COMBINER1_NV',
'GL_COMBINER2_NV', 'GL_COMBINER3_NV', 'GL_COMBINER4_NV', 'GL_COMBINER5_NV',
'GL_COMBINER6_NV', 'GL_COMBINER7_NV', 'GL_FOG_DISTANCE_MODE_NV',
'GL_EYE_RADIAL_NV', 'GL_EYE_PLANE_ABSOLUTE_NV', 'GL_EMBOSS_LIGHT_NV',
'GL_EMBOSS_CONSTANT_NV', 'GL_EMBOSS_MAP_NV', 'GL_COMBINE4_NV',
'GL_SOURCE3_RGB_NV', 'GL_SOURCE3_ALPHA_NV', 'GL_OPERAND3_RGB_NV',
'GL_OPERAND3_ALPHA_NV', 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT',
'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT', 'GL_COMPRESSED_RGBA_S3TC_DXT3_EXT',
'GL_COMPRESSED_RGBA_S3TC_DXT5_EXT', 'GL_CULL_VERTEX_IBM',
'GL_VERTEX_ARRAY_LIST_IBM', 'GL_NORMAL_ARRAY_LIST_IBM',
'GL_COLOR_ARRAY_LIST_IBM', 'GL_INDEX_ARRAY_LIST_IBM',
'GL_TEXTURE_COORD_ARRAY_LIST_IBM', 'GL_EDGE_FLAG_ARRAY_LIST_IBM',
'GL_FOG_COORDINATE_ARRAY_LIST_IBM', 'GL_SECONDARY_COLOR_ARRAY_LIST_IBM',
'GL_VERTEX_ARRAY_LIST_STRIDE_IBM', 'GL_NORMAL_ARRAY_LIST_STRIDE_IBM',
'GL_COLOR_ARRAY_LIST_STRIDE_IBM', 'GL_INDEX_ARRAY_LIST_STRIDE_IBM',
'GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM',
'GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM',
'GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM',
'GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM', 'GL_PACK_SUBSAMPLE_RATE_SGIX',
'GL_UNPACK_SUBSAMPLE_RATE_SGIX', 'GL_PIXEL_SUBSAMPLE_4444_SGIX',
'GL_PIXEL_SUBSAMPLE_2424_SGIX', 'GL_PIXEL_SUBSAMPLE_4242_SGIX',
'GL_YCRCB_SGIX', 'GL_YCRCBA_SGIX', 'GL_DEPTH_PASS_INSTRUMENT_SGIX',
'GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX', 'GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX',
'GL_COMPRESSED_RGB_FXT1_3DFX', 'GL_COMPRESSED_RGBA_FXT1_3DFX',
'GL_MULTISAMPLE_3DFX', 'GL_SAMPLE_BUFFERS_3DFX', 'GL_SAMPLES_3DFX',
'GL_MULTISAMPLE_BIT_3DFX', 'GL_MULTISAMPLE_EXT',
'GL_SAMPLE_ALPHA_TO_MASK_EXT', 'GL_SAMPLE_ALPHA_TO_ONE_EXT',
'GL_SAMPLE_MASK_EXT', 'GL_1PASS_EXT', 'GL_2PASS_0_EXT', 'GL_2PASS_1_EXT',
'GL_4PASS_0_EXT', 'GL_4PASS_1_EXT', 'GL_4PASS_2_EXT', 'GL_4PASS_3_EXT',
'GL_SAMPLE_BUFFERS_EXT', 'GL_SAMPLES_EXT', 'GL_SAMPLE_MASK_VALUE_EXT',
'GL_SAMPLE_MASK_INVERT_EXT', 'GL_SAMPLE_PATTERN_EXT',
'GL_MULTISAMPLE_BIT_EXT', 'GL_VERTEX_PRECLIP_SGIX',
'GL_VERTEX_PRECLIP_HINT_SGIX', 'GL_CONVOLUTION_HINT_SGIX',
'GL_PACK_RESAMPLE_SGIX', 'GL_UNPACK_RESAMPLE_SGIX',
'GL_RESAMPLE_REPLICATE_SGIX', 'GL_RESAMPLE_ZERO_FILL_SGIX',
'GL_RESAMPLE_DECIMATE_SGIX', 'GL_EYE_DISTANCE_TO_POINT_SGIS',
'GL_OBJECT_DISTANCE_TO_POINT_SGIS', 'GL_EYE_DISTANCE_TO_LINE_SGIS',
'GL_OBJECT_DISTANCE_TO_LINE_SGIS', 'GL_EYE_POINT_SGIS',
'GL_OBJECT_POINT_SGIS', 'GL_EYE_LINE_SGIS', 'GL_OBJECT_LINE_SGIS',
'GL_TEXTURE_COLOR_WRITEMASK_SGIS', 'GL_DOT3_RGB_EXT', 'GL_DOT3_RGBA_EXT',
'GL_MIRROR_CLAMP_ATI', 'GL_MIRROR_CLAMP_TO_EDGE_ATI', 'GL_ALL_COMPLETED_NV',
'GL_FENCE_STATUS_NV', 'GL_FENCE_CONDITION_NV', 'GL_MIRRORED_REPEAT_IBM',
'GL_EVAL_2D_NV', 'GL_EVAL_TRIANGULAR_2D_NV', 'GL_MAP_TESSELLATION_NV',
'GL_MAP_ATTRIB_U_ORDER_NV', 'GL_MAP_ATTRIB_V_ORDER_NV',
'GL_EVAL_FRACTIONAL_TESSELLATION_NV', 'GL_EVAL_VERTEX_ATTRIB0_NV',
'GL_EVAL_VERTEX_ATTRIB1_NV', 'GL_EVAL_VERTEX_ATTRIB2_NV',
'GL_EVAL_VERTEX_ATTRIB3_NV', 'GL_EVAL_VERTEX_ATTRIB4_NV',
'GL_EVAL_VERTEX_ATTRIB5_NV', 'GL_EVAL_VERTEX_ATTRIB6_NV',
'GL_EVAL_VERTEX_ATTRIB7_NV', 'GL_EVAL_VERTEX_ATTRIB8_NV',
'GL_EVAL_VERTEX_ATTRIB9_NV', 'GL_EVAL_VERTEX_ATTRIB10_NV',
'GL_EVAL_VERTEX_ATTRIB11_NV', 'GL_EVAL_VERTEX_ATTRIB12_NV',
'GL_EVAL_VERTEX_ATTRIB13_NV', 'GL_EVAL_VERTEX_ATTRIB14_NV',
'GL_EVAL_VERTEX_ATTRIB15_NV', 'GL_MAX_MAP_TESSELLATION_NV',
'GL_MAX_RATIONAL_EVAL_ORDER_NV', 'GL_DEPTH_STENCIL_NV',
'GL_UNSIGNED_INT_24_8_NV', 'GL_DEPTH_STENCIL_EXT', 'GL_DEPTH24_STENCIL8_EXT',
'GL_TEXTURE_STENCIL_SIZE_EXT', 'GL_UNSIGNED_INT_24_8_EXT',
'GL_PER_STAGE_CONSTANTS_NV', 'GL_TEXTURE_RECTANGLE_NV',
'GL_TEXTURE_BINDING_RECTANGLE_NV', 'GL_PROXY_TEXTURE_RECTANGLE_NV',
'GL_MAX_RECTANGLE_TEXTURE_SIZE_NV', 'GL_OFFSET_TEXTURE_RECTANGLE_NV',
'GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV', 'GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV',
'GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV', 'GL_UNSIGNED_INT_S8_S8_8_8_NV',
'GL_UNSIGNED_INT_8_8_S8_S8_REV_NV', 'GL_DSDT_MAG_INTENSITY_NV',
'GL_SHADER_CONSISTENT_NV', 'GL_TEXTURE_SHADER_NV', 'GL_SHADER_OPERATION_NV',
'GL_CULL_MODES_NV', 'GL_OFFSET_TEXTURE_MATRIX_NV',
'GL_OFFSET_TEXTURE_SCALE_NV', 'GL_OFFSET_TEXTURE_BIAS_NV',
'GL_OFFSET_TEXTURE_2D_MATRIX_NV', 'GL_OFFSET_TEXTURE_2D_SCALE_NV',
'GL_OFFSET_TEXTURE_2D_BIAS_NV', 'GL_PREVIOUS_TEXTURE_INPUT_NV',
'GL_CONST_EYE_NV', 'GL_PASS_THROUGH_NV', 'GL_CULL_FRAGMENT_NV',
'GL_OFFSET_TEXTURE_2D_NV', 'GL_DEPENDENT_AR_TEXTURE_2D_NV',
'GL_DEPENDENT_GB_TEXTURE_2D_NV', 'GL_DOT_PRODUCT_NV',
'GL_DOT_PRODUCT_DEPTH_REPLACE_NV', 'GL_DOT_PRODUCT_TEXTURE_2D_NV',
'GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV', 'GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV',
'GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV',
'GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV', 'GL_HILO_NV', 'GL_DSDT_NV',
'GL_DSDT_MAG_NV', 'GL_DSDT_MAG_VIB_NV', 'GL_HILO16_NV', 'GL_SIGNED_HILO_NV',
'GL_SIGNED_HILO16_NV', 'GL_SIGNED_RGBA_NV', 'GL_SIGNED_RGBA8_NV',
'GL_SIGNED_RGB_NV', 'GL_SIGNED_RGB8_NV', 'GL_SIGNED_LUMINANCE_NV',
'GL_SIGNED_LUMINANCE8_NV', 'GL_SIGNED_LUMINANCE_ALPHA_NV',
'GL_SIGNED_LUMINANCE8_ALPHA8_NV', 'GL_SIGNED_ALPHA_NV', 'GL_SIGNED_ALPHA8_NV',
'GL_SIGNED_INTENSITY_NV', 'GL_SIGNED_INTENSITY8_NV', 'GL_DSDT8_NV',
'GL_DSDT8_MAG8_NV', 'GL_DSDT8_MAG8_INTENSITY8_NV',
'GL_SIGNED_RGB_UNSIGNED_ALPHA_NV', 'GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV',
'GL_HI_SCALE_NV', 'GL_LO_SCALE_NV', 'GL_DS_SCALE_NV', 'GL_DT_SCALE_NV',
'GL_MAGNITUDE_SCALE_NV', 'GL_VIBRANCE_SCALE_NV', 'GL_HI_BIAS_NV',
'GL_LO_BIAS_NV', 'GL_DS_BIAS_NV', 'GL_DT_BIAS_NV', 'GL_MAGNITUDE_BIAS_NV',
'GL_VIBRANCE_BIAS_NV', 'GL_TEXTURE_BORDER_VALUES_NV', 'GL_TEXTURE_HI_SIZE_NV',
'GL_TEXTURE_LO_SIZE_NV', 'GL_TEXTURE_DS_SIZE_NV', 'GL_TEXTURE_DT_SIZE_NV',
'GL_TEXTURE_MAG_SIZE_NV', 'GL_DOT_PRODUCT_TEXTURE_3D_NV',
'GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV', 'GL_VERTEX_PROGRAM_NV',
'GL_VERTEX_STATE_PROGRAM_NV', 'GL_ATTRIB_ARRAY_SIZE_NV',
'GL_ATTRIB_ARRAY_STRIDE_NV', 'GL_ATTRIB_ARRAY_TYPE_NV',
'GL_CURRENT_ATTRIB_NV', 'GL_PROGRAM_LENGTH_NV', 'GL_PROGRAM_STRING_NV',
'GL_MODELVIEW_PROJECTION_NV', 'GL_IDENTITY_NV', 'GL_INVERSE_NV',
'GL_TRANSPOSE_NV', 'GL_INVERSE_TRANSPOSE_NV',
'GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV', 'GL_MAX_TRACK_MATRICES_NV',
'GL_MATRIX0_NV', 'GL_MATRIX1_NV', 'GL_MATRIX2_NV', 'GL_MATRIX3_NV',
'GL_MATRIX4_NV', 'GL_MATRIX5_NV', 'GL_MATRIX6_NV', 'GL_MATRIX7_NV',
'GL_CURRENT_MATRIX_STACK_DEPTH_NV', 'GL_CURRENT_MATRIX_NV',
'GL_VERTEX_PROGRAM_POINT_SIZE_NV', 'GL_VERTEX_PROGRAM_TWO_SIDE_NV',
'GL_PROGRAM_PARAMETER_NV', 'GL_ATTRIB_ARRAY_POINTER_NV',
'GL_PROGRAM_TARGET_NV', 'GL_PROGRAM_RESIDENT_NV', 'GL_TRACK_MATRIX_NV',
'GL_TRACK_MATRIX_TRANSFORM_NV', 'GL_VERTEX_PROGRAM_BINDING_NV',
'GL_PROGRAM_ERROR_POSITION_NV', 'GL_VERTEX_ATTRIB_ARRAY0_NV',
'GL_VERTEX_ATTRIB_ARRAY1_NV', 'GL_VERTEX_ATTRIB_ARRAY2_NV',
'GL_VERTEX_ATTRIB_ARRAY3_NV', 'GL_VERTEX_ATTRIB_ARRAY4_NV',
'GL_VERTEX_ATTRIB_ARRAY5_NV', 'GL_VERTEX_ATTRIB_ARRAY6_NV',
'GL_VERTEX_ATTRIB_ARRAY7_NV', 'GL_VERTEX_ATTRIB_ARRAY8_NV',
'GL_VERTEX_ATTRIB_ARRAY9_NV', 'GL_VERTEX_ATTRIB_ARRAY10_NV',
'GL_VERTEX_ATTRIB_ARRAY11_NV', 'GL_VERTEX_ATTRIB_ARRAY12_NV',
'GL_VERTEX_ATTRIB_ARRAY13_NV', 'GL_VERTEX_ATTRIB_ARRAY14_NV',
'GL_VERTEX_ATTRIB_ARRAY15_NV', 'GL_MAP1_VERTEX_ATTRIB0_4_NV',
'GL_MAP1_VERTEX_ATTRIB1_4_NV', 'GL_MAP1_VERTEX_ATTRIB2_4_NV',
'GL_MAP1_VERTEX_ATTRIB3_4_NV', 'GL_MAP1_VERTEX_ATTRIB4_4_NV',
'GL_MAP1_VERTEX_ATTRIB5_4_NV', 'GL_MAP1_VERTEX_ATTRIB6_4_NV',
'GL_MAP1_VERTEX_ATTRIB7_4_NV', 'GL_MAP1_VERTEX_ATTRIB8_4_NV',
'GL_MAP1_VERTEX_ATTRIB9_4_NV', 'GL_MAP1_VERTEX_ATTRIB10_4_NV',
'GL_MAP1_VERTEX_ATTRIB11_4_NV', 'GL_MAP1_VERTEX_ATTRIB12_4_NV',
'GL_MAP1_VERTEX_ATTRIB13_4_NV', 'GL_MAP1_VERTEX_ATTRIB14_4_NV',
'GL_MAP1_VERTEX_ATTRIB15_4_NV', 'GL_MAP2_VERTEX_ATTRIB0_4_NV',
'GL_MAP2_VERTEX_ATTRIB1_4_NV', 'GL_MAP2_VERTEX_ATTRIB2_4_NV',
'GL_MAP2_VERTEX_ATTRIB3_4_NV', 'GL_MAP2_VERTEX_ATTRIB4_4_NV',
'GL_MAP2_VERTEX_ATTRIB5_4_NV', 'GL_MAP2_VERTEX_ATTRIB6_4_NV',
'GL_MAP2_VERTEX_ATTRIB7_4_NV', 'GL_MAP2_VERTEX_ATTRIB8_4_NV',
'GL_MAP2_VERTEX_ATTRIB9_4_NV', 'GL_MAP2_VERTEX_ATTRIB10_4_NV',
'GL_MAP2_VERTEX_ATTRIB11_4_NV', 'GL_MAP2_VERTEX_ATTRIB12_4_NV',
'GL_MAP2_VERTEX_ATTRIB13_4_NV', 'GL_MAP2_VERTEX_ATTRIB14_4_NV',
'GL_MAP2_VERTEX_ATTRIB15_4_NV', 'GL_TEXTURE_MAX_CLAMP_S_SGIX',
'GL_TEXTURE_MAX_CLAMP_T_SGIX', 'GL_TEXTURE_MAX_CLAMP_R_SGIX',
'GL_SCALEBIAS_HINT_SGIX', 'GL_INTERLACE_OML', 'GL_INTERLACE_READ_OML',
'GL_FORMAT_SUBSAMPLE_24_24_OML', 'GL_FORMAT_SUBSAMPLE_244_244_OML',
'GL_PACK_RESAMPLE_OML', 'GL_UNPACK_RESAMPLE_OML', 'GL_RESAMPLE_REPLICATE_OML',
'GL_RESAMPLE_ZERO_FILL_OML', 'GL_RESAMPLE_AVERAGE_OML',
'GL_RESAMPLE_DECIMATE_OML', 'GL_DEPTH_STENCIL_TO_RGBA_NV',
'GL_DEPTH_STENCIL_TO_BGRA_NV', 'GL_BUMP_ROT_MATRIX_ATI',
'GL_BUMP_ROT_MATRIX_SIZE_ATI', 'GL_BUMP_NUM_TEX_UNITS_ATI',
'GL_BUMP_TEX_UNITS_ATI', 'GL_DUDV_ATI', 'GL_DU8DV8_ATI', 'GL_BUMP_ENVMAP_ATI',
'GL_BUMP_TARGET_ATI', 'GL_FRAGMENT_SHADER_ATI', 'GL_REG_0_ATI',
'GL_REG_1_ATI', 'GL_REG_2_ATI', 'GL_REG_3_ATI', 'GL_REG_4_ATI',
'GL_REG_5_ATI', 'GL_REG_6_ATI', 'GL_REG_7_ATI', 'GL_REG_8_ATI',
'GL_REG_9_ATI', 'GL_REG_10_ATI', 'GL_REG_11_ATI', 'GL_REG_12_ATI',
'GL_REG_13_ATI', 'GL_REG_14_ATI', 'GL_REG_15_ATI', 'GL_REG_16_ATI',
'GL_REG_17_ATI', 'GL_REG_18_ATI', 'GL_REG_19_ATI', 'GL_REG_20_ATI',
'GL_REG_21_ATI', 'GL_REG_22_ATI', 'GL_REG_23_ATI', 'GL_REG_24_ATI',
'GL_REG_25_ATI', 'GL_REG_26_ATI', 'GL_REG_27_ATI', 'GL_REG_28_ATI',
'GL_REG_29_ATI', 'GL_REG_30_ATI', 'GL_REG_31_ATI', 'GL_CON_0_ATI',
'GL_CON_1_ATI', 'GL_CON_2_ATI', 'GL_CON_3_ATI', 'GL_CON_4_ATI',
'GL_CON_5_ATI', 'GL_CON_6_ATI', 'GL_CON_7_ATI', 'GL_CON_8_ATI',
'GL_CON_9_ATI', 'GL_CON_10_ATI', 'GL_CON_11_ATI', 'GL_CON_12_ATI',
'GL_CON_13_ATI', 'GL_CON_14_ATI', 'GL_CON_15_ATI', 'GL_CON_16_ATI',
'GL_CON_17_ATI', 'GL_CON_18_ATI', 'GL_CON_19_ATI', 'GL_CON_20_ATI',
'GL_CON_21_ATI', 'GL_CON_22_ATI', 'GL_CON_23_ATI', 'GL_CON_24_ATI',
'GL_CON_25_ATI', 'GL_CON_26_ATI', 'GL_CON_27_ATI', 'GL_CON_28_ATI',
'GL_CON_29_ATI', 'GL_CON_30_ATI', 'GL_CON_31_ATI', 'GL_MOV_ATI', 'GL_ADD_ATI',
'GL_MUL_ATI', 'GL_SUB_ATI', 'GL_DOT3_ATI', 'GL_DOT4_ATI', 'GL_MAD_ATI',
'GL_LERP_ATI', 'GL_CND_ATI', 'GL_CND0_ATI', 'GL_DOT2_ADD_ATI',
'GL_SECONDARY_INTERPOLATOR_ATI', 'GL_NUM_FRAGMENT_REGISTERS_ATI',
'GL_NUM_FRAGMENT_CONSTANTS_ATI', 'GL_NUM_PASSES_ATI',
'GL_NUM_INSTRUCTIONS_PER_PASS_ATI', 'GL_NUM_INSTRUCTIONS_TOTAL_ATI',
'GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI', 'GL_NUM_LOOPBACK_COMPONENTS_ATI',
'GL_COLOR_ALPHA_PAIRING_ATI', 'GL_SWIZZLE_STR_ATI', 'GL_SWIZZLE_STQ_ATI',
'GL_SWIZZLE_STR_DR_ATI', 'GL_SWIZZLE_STQ_DQ_ATI', 'GL_SWIZZLE_STRQ_ATI',
'GL_SWIZZLE_STRQ_DQ_ATI', 'GL_RED_BIT_ATI', 'GL_GREEN_BIT_ATI',
'GL_BLUE_BIT_ATI', 'GL_2X_BIT_ATI', 'GL_4X_BIT_ATI', 'GL_8X_BIT_ATI',
'GL_HALF_BIT_ATI', 'GL_QUARTER_BIT_ATI', 'GL_EIGHTH_BIT_ATI',
'GL_SATURATE_BIT_ATI', 'GL_COMP_BIT_ATI', 'GL_NEGATE_BIT_ATI',
'GL_BIAS_BIT_ATI', 'GL_PN_TRIANGLES_ATI',
'GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI', 'GL_PN_TRIANGLES_POINT_MODE_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_ATI', 'GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI',
'GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI',
'GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI', 'GL_STATIC_ATI',
'GL_DYNAMIC_ATI', 'GL_PRESERVE_ATI', 'GL_DISCARD_ATI',
'GL_OBJECT_BUFFER_SIZE_ATI', 'GL_OBJECT_BUFFER_USAGE_ATI',
'GL_ARRAY_OBJECT_BUFFER_ATI', 'GL_ARRAY_OBJECT_OFFSET_ATI',
'GL_VERTEX_SHADER_EXT', 'GL_VERTEX_SHADER_BINDING_EXT', 'GL_OP_INDEX_EXT',
'GL_OP_NEGATE_EXT', 'GL_OP_DOT3_EXT', 'GL_OP_DOT4_EXT', 'GL_OP_MUL_EXT',
'GL_OP_ADD_EXT', 'GL_OP_MADD_EXT', 'GL_OP_FRAC_EXT', 'GL_OP_MAX_EXT',
'GL_OP_MIN_EXT', 'GL_OP_SET_GE_EXT', 'GL_OP_SET_LT_EXT', 'GL_OP_CLAMP_EXT',
'GL_OP_FLOOR_EXT', 'GL_OP_ROUND_EXT', 'GL_OP_EXP_BASE_2_EXT',
'GL_OP_LOG_BASE_2_EXT', 'GL_OP_POWER_EXT', 'GL_OP_RECIP_EXT',
'GL_OP_RECIP_SQRT_EXT', 'GL_OP_SUB_EXT', 'GL_OP_CROSS_PRODUCT_EXT',
'GL_OP_MULTIPLY_MATRIX_EXT', 'GL_OP_MOV_EXT', 'GL_OUTPUT_VERTEX_EXT',
'GL_OUTPUT_COLOR0_EXT', 'GL_OUTPUT_COLOR1_EXT',
'GL_OUTPUT_TEXTURE_COORD0_EXT', 'GL_OUTPUT_TEXTURE_COORD1_EXT',
'GL_OUTPUT_TEXTURE_COORD2_EXT', 'GL_OUTPUT_TEXTURE_COORD3_EXT',
'GL_OUTPUT_TEXTURE_COORD4_EXT', 'GL_OUTPUT_TEXTURE_COORD5_EXT',
'GL_OUTPUT_TEXTURE_COORD6_EXT', 'GL_OUTPUT_TEXTURE_COORD7_EXT',
'GL_OUTPUT_TEXTURE_COORD8_EXT', 'GL_OUTPUT_TEXTURE_COORD9_EXT',
'GL_OUTPUT_TEXTURE_COORD10_EXT', 'GL_OUTPUT_TEXTURE_COORD11_EXT',
'GL_OUTPUT_TEXTURE_COORD12_EXT', 'GL_OUTPUT_TEXTURE_COORD13_EXT',
'GL_OUTPUT_TEXTURE_COORD14_EXT', 'GL_OUTPUT_TEXTURE_COORD15_EXT',
'GL_OUTPUT_TEXTURE_COORD16_EXT', 'GL_OUTPUT_TEXTURE_COORD17_EXT',
'GL_OUTPUT_TEXTURE_COORD18_EXT', 'GL_OUTPUT_TEXTURE_COORD19_EXT',
'GL_OUTPUT_TEXTURE_COORD20_EXT', 'GL_OUTPUT_TEXTURE_COORD21_EXT',
'GL_OUTPUT_TEXTURE_COORD22_EXT', 'GL_OUTPUT_TEXTURE_COORD23_EXT',
'GL_OUTPUT_TEXTURE_COORD24_EXT', 'GL_OUTPUT_TEXTURE_COORD25_EXT',
'GL_OUTPUT_TEXTURE_COORD26_EXT', 'GL_OUTPUT_TEXTURE_COORD27_EXT',
'GL_OUTPUT_TEXTURE_COORD28_EXT', 'GL_OUTPUT_TEXTURE_COORD29_EXT',
'GL_OUTPUT_TEXTURE_COORD30_EXT', 'GL_OUTPUT_TEXTURE_COORD31_EXT',
'GL_OUTPUT_FOG_EXT', 'GL_SCALAR_EXT', 'GL_VECTOR_EXT', 'GL_MATRIX_EXT',
'GL_VARIANT_EXT', 'GL_INVARIANT_EXT', 'GL_LOCAL_CONSTANT_EXT', 'GL_LOCAL_EXT',
'GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT', 'GL_MAX_VERTEX_SHADER_VARIANTS_EXT',
'GL_MAX_VERTEX_SHADER_INVARIANTS_EXT',
'GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT', 'GL_MAX_VERTEX_SHADER_LOCALS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT',
'GL_VERTEX_SHADER_INSTRUCTIONS_EXT', 'GL_VERTEX_SHADER_VARIANTS_EXT',
'GL_VERTEX_SHADER_INVARIANTS_EXT', 'GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',
'GL_VERTEX_SHADER_LOCALS_EXT', 'GL_VERTEX_SHADER_OPTIMIZED_EXT', 'GL_X_EXT',
'GL_Y_EXT', 'GL_Z_EXT', 'GL_W_EXT', 'GL_NEGATIVE_X_EXT', 'GL_NEGATIVE_Y_EXT',
'GL_NEGATIVE_Z_EXT', 'GL_NEGATIVE_W_EXT', 'GL_ZERO_EXT', 'GL_ONE_EXT',
'GL_NEGATIVE_ONE_EXT', 'GL_NORMALIZED_RANGE_EXT', 'GL_FULL_RANGE_EXT',
'GL_CURRENT_VERTEX_EXT', 'GL_MVP_MATRIX_EXT', 'GL_VARIANT_VALUE_EXT',
'GL_VARIANT_DATATYPE_EXT', 'GL_VARIANT_ARRAY_STRIDE_EXT',
'GL_VARIANT_ARRAY_TYPE_EXT', 'GL_VARIANT_ARRAY_EXT',
'GL_VARIANT_ARRAY_POINTER_EXT', 'GL_INVARIANT_VALUE_EXT',
'GL_INVARIANT_DATATYPE_EXT', 'GL_LOCAL_CONSTANT_VALUE_EXT',
'GL_LOCAL_CONSTANT_DATATYPE_EXT', 'GL_MAX_VERTEX_STREAMS_ATI',
'GL_VERTEX_STREAM0_ATI', 'GL_VERTEX_STREAM1_ATI', 'GL_VERTEX_STREAM2_ATI',
'GL_VERTEX_STREAM3_ATI', 'GL_VERTEX_STREAM4_ATI', 'GL_VERTEX_STREAM5_ATI',
'GL_VERTEX_STREAM6_ATI', 'GL_VERTEX_STREAM7_ATI', 'GL_VERTEX_SOURCE_ATI',
'GL_ELEMENT_ARRAY_ATI', 'GL_ELEMENT_ARRAY_TYPE_ATI',
'GL_ELEMENT_ARRAY_POINTER_ATI', 'GL_QUAD_MESH_SUN', 'GL_TRIANGLE_MESH_SUN',
'GL_SLICE_ACCUM_SUN', 'GL_MULTISAMPLE_FILTER_HINT_NV', 'GL_DEPTH_CLAMP_NV',
'GL_PIXEL_COUNTER_BITS_NV', 'GL_CURRENT_OCCLUSION_QUERY_ID_NV',
'GL_PIXEL_COUNT_NV', 'GL_PIXEL_COUNT_AVAILABLE_NV', 'GL_POINT_SPRITE_NV',
'GL_COORD_REPLACE_NV', 'GL_POINT_SPRITE_R_MODE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV',
'GL_OFFSET_HILO_TEXTURE_2D_NV', 'GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV',
'GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV',
'GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV',
'GL_DEPENDENT_HILO_TEXTURE_2D_NV', 'GL_DEPENDENT_RGB_TEXTURE_3D_NV',
'GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV', 'GL_DOT_PRODUCT_PASS_THROUGH_NV',
'GL_DOT_PRODUCT_TEXTURE_1D_NV', 'GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV',
'GL_HILO8_NV', 'GL_SIGNED_HILO8_NV', 'GL_FORCE_BLUE_TO_ONE_NV',
'GL_STENCIL_TEST_TWO_SIDE_EXT', 'GL_ACTIVE_STENCIL_FACE_EXT',
'GL_TEXT_FRAGMENT_SHADER_ATI', 'GL_UNPACK_CLIENT_STORAGE_APPLE',
'GL_ELEMENT_ARRAY_APPLE', 'GL_ELEMENT_ARRAY_TYPE_APPLE',
'GL_ELEMENT_ARRAY_POINTER_APPLE', 'GL_DRAW_PIXELS_APPLE', 'GL_FENCE_APPLE',
'GL_VERTEX_ARRAY_BINDING_APPLE', 'GL_VERTEX_ARRAY_RANGE_APPLE',
'GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE', 'GL_VERTEX_ARRAY_STORAGE_HINT_APPLE',
'GL_VERTEX_ARRAY_RANGE_POINTER_APPLE', 'GL_STORAGE_CACHED_APPLE',
'GL_STORAGE_SHARED_APPLE', 'GL_YCBCR_422_APPLE',
'GL_UNSIGNED_SHORT_8_8_APPLE', 'GL_UNSIGNED_SHORT_8_8_REV_APPLE',
'GL_RGB_S3TC', 'GL_RGB4_S3TC', 'GL_RGBA_S3TC', 'GL_RGBA4_S3TC',
'GL_MAX_DRAW_BUFFERS_ATI', 'GL_DRAW_BUFFER0_ATI', 'GL_DRAW_BUFFER1_ATI',
'GL_DRAW_BUFFER2_ATI', 'GL_DRAW_BUFFER3_ATI', 'GL_DRAW_BUFFER4_ATI',
'GL_DRAW_BUFFER5_ATI', 'GL_DRAW_BUFFER6_ATI', 'GL_DRAW_BUFFER7_ATI',
'GL_DRAW_BUFFER8_ATI', 'GL_DRAW_BUFFER9_ATI', 'GL_DRAW_BUFFER10_ATI',
'GL_DRAW_BUFFER11_ATI', 'GL_DRAW_BUFFER12_ATI', 'GL_DRAW_BUFFER13_ATI',
'GL_DRAW_BUFFER14_ATI', 'GL_DRAW_BUFFER15_ATI', 'GL_TYPE_RGBA_FLOAT_ATI',
'GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI', 'GL_MODULATE_ADD_ATI',
'GL_MODULATE_SIGNED_ADD_ATI', 'GL_MODULATE_SUBTRACT_ATI',
'GL_RGBA_FLOAT32_ATI', 'GL_RGB_FLOAT32_ATI', 'GL_ALPHA_FLOAT32_ATI',
'GL_INTENSITY_FLOAT32_ATI', 'GL_LUMINANCE_FLOAT32_ATI',
'GL_LUMINANCE_ALPHA_FLOAT32_ATI', 'GL_RGBA_FLOAT16_ATI', 'GL_RGB_FLOAT16_ATI',
'GL_ALPHA_FLOAT16_ATI', 'GL_INTENSITY_FLOAT16_ATI',
'GL_LUMINANCE_FLOAT16_ATI', 'GL_LUMINANCE_ALPHA_FLOAT16_ATI', 'GL_FLOAT_R_NV',
'GL_FLOAT_RG_NV', 'GL_FLOAT_RGB_NV', 'GL_FLOAT_RGBA_NV', 'GL_FLOAT_R16_NV',
'GL_FLOAT_R32_NV', 'GL_FLOAT_RG16_NV', 'GL_FLOAT_RG32_NV',
'GL_FLOAT_RGB16_NV', 'GL_FLOAT_RGB32_NV', 'GL_FLOAT_RGBA16_NV',
'GL_FLOAT_RGBA32_NV', 'GL_TEXTURE_FLOAT_COMPONENTS_NV',
'GL_FLOAT_CLEAR_COLOR_VALUE_NV', 'GL_FLOAT_RGBA_MODE_NV',
'GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV', 'GL_FRAGMENT_PROGRAM_NV',
'GL_MAX_TEXTURE_COORDS_NV', 'GL_MAX_TEXTURE_IMAGE_UNITS_NV',
'GL_FRAGMENT_PROGRAM_BINDING_NV', 'GL_PROGRAM_ERROR_STRING_NV',
'GL_HALF_FLOAT_NV', 'GL_WRITE_PIXEL_DATA_RANGE_NV',
'GL_READ_PIXEL_DATA_RANGE_NV', 'GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV',
'GL_READ_PIXEL_DATA_RANGE_LENGTH_NV', 'GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV',
'GL_READ_PIXEL_DATA_RANGE_POINTER_NV', 'GL_PRIMITIVE_RESTART_NV',
'GL_PRIMITIVE_RESTART_INDEX_NV', 'GL_TEXTURE_UNSIGNED_REMAP_MODE_NV',
'GL_STENCIL_BACK_FUNC_ATI', 'GL_STENCIL_BACK_FAIL_ATI',
'GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI', 'GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI',
'GL_IMPLEMENTATION_COLOR_READ_TYPE_OES',
'GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES', 'GL_DEPTH_BOUNDS_TEST_EXT',
'GL_DEPTH_BOUNDS_EXT', 'GL_MIRROR_CLAMP_EXT', 'GL_MIRROR_CLAMP_TO_EDGE_EXT',
'GL_MIRROR_CLAMP_TO_BORDER_EXT', 'GL_BLEND_EQUATION_RGB_EXT',
'GL_BLEND_EQUATION_ALPHA_EXT', 'GL_PACK_INVERT_MESA',
'GL_UNSIGNED_SHORT_8_8_MESA', 'GL_UNSIGNED_SHORT_8_8_REV_MESA',
'GL_YCBCR_MESA', 'GL_PIXEL_PACK_BUFFER_EXT', 'GL_PIXEL_UNPACK_BUFFER_EXT',
'GL_PIXEL_PACK_BUFFER_BINDING_EXT', 'GL_PIXEL_UNPACK_BUFFER_BINDING_EXT',
'GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV', 'GL_MAX_PROGRAM_CALL_DEPTH_NV',
'GL_MAX_PROGRAM_IF_DEPTH_NV', 'GL_MAX_PROGRAM_LOOP_DEPTH_NV',
'GL_MAX_PROGRAM_LOOP_COUNT_NV', 'GL_INVALID_FRAMEBUFFER_OPERATION_EXT',
'GL_MAX_RENDERBUFFER_SIZE_EXT', 'GL_FRAMEBUFFER_BINDING_EXT',
'GL_RENDERBUFFER_BINDING_EXT', 'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT',
'GL_FRAMEBUFFER_COMPLETE_EXT', 'GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT', 'GL_FRAMEBUFFER_UNSUPPORTED_EXT',
'GL_MAX_COLOR_ATTACHMENTS_EXT', 'GL_COLOR_ATTACHMENT0_EXT',
'GL_COLOR_ATTACHMENT1_EXT', 'GL_COLOR_ATTACHMENT2_EXT',
'GL_COLOR_ATTACHMENT3_EXT', 'GL_COLOR_ATTACHMENT4_EXT',
'GL_COLOR_ATTACHMENT5_EXT', 'GL_COLOR_ATTACHMENT6_EXT',
'GL_COLOR_ATTACHMENT7_EXT', 'GL_COLOR_ATTACHMENT8_EXT',
'GL_COLOR_ATTACHMENT9_EXT', 'GL_COLOR_ATTACHMENT10_EXT',
'GL_COLOR_ATTACHMENT11_EXT', 'GL_COLOR_ATTACHMENT12_EXT',
'GL_COLOR_ATTACHMENT13_EXT', 'GL_COLOR_ATTACHMENT14_EXT',
'GL_COLOR_ATTACHMENT15_EXT', 'GL_DEPTH_ATTACHMENT_EXT',
'GL_STENCIL_ATTACHMENT_EXT', 'GL_FRAMEBUFFER_EXT', 'GL_RENDERBUFFER_EXT',
'GL_RENDERBUFFER_WIDTH_EXT', 'GL_RENDERBUFFER_HEIGHT_EXT',
'GL_RENDERBUFFER_INTERNAL_FORMAT_EXT', 'GL_STENCIL_INDEX_EXT',
'GL_STENCIL_INDEX1_EXT', 'GL_STENCIL_INDEX4_EXT', 'GL_STENCIL_INDEX8_EXT',
'GL_STENCIL_INDEX16_EXT', 'GL_RENDERBUFFER_RED_SIZE_EXT',
'GL_RENDERBUFFER_GREEN_SIZE_EXT', 'GL_RENDERBUFFER_BLUE_SIZE_EXT',
'GL_RENDERBUFFER_ALPHA_SIZE_EXT', 'GL_RENDERBUFFER_DEPTH_SIZE_EXT',
'GL_RENDERBUFFER_STENCIL_SIZE_EXT', 'GL_CG_VERTEX_SHADER_EXT',
'GL_CG_FRAGMENT_SHADER_EXT', 'GL_TIME_ELAPSED_EXT', 'GL_TEXTURE_BUFFER_EXT',
'GL_MAX_TEXTURE_BUFFER_SIZE_EXT', 'GL_TEXTURE_BINDING_BUFFER_EXT',
'GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT', 'GL_TEXTURE_BUFFER_FORMAT_EXT',
'GL_SAMPLER_1D_ARRAY_EXT', 'GL_SAMPLER_2D_ARRAY_EXT', 'GL_SAMPLER_BUFFER_EXT',
'GL_SAMPLER_1D_ARRAY_SHADOW_EXT', 'GL_SAMPLER_2D_ARRAY_SHADOW_EXT',
'GL_SAMPLER_CUBE_SHADOW_EXT', 'GL_UNSIGNED_INT_VEC2_EXT',
'GL_UNSIGNED_INT_VEC3_EXT', 'GL_UNSIGNED_INT_VEC4_EXT',
'GL_INT_SAMPLER_1D_EXT', 'GL_INT_SAMPLER_2D_EXT', 'GL_INT_SAMPLER_3D_EXT',
'GL_INT_SAMPLER_CUBE_EXT', 'GL_INT_SAMPLER_2D_RECT_EXT',
'GL_INT_SAMPLER_1D_ARRAY_EXT', 'GL_INT_SAMPLER_2D_ARRAY_EXT',
'GL_INT_SAMPLER_BUFFER_EXT', 'GL_UNSIGNED_INT_SAMPLER_1D_EXT',
'GL_UNSIGNED_INT_SAMPLER_2D_EXT', 'GL_UNSIGNED_INT_SAMPLER_3D_EXT',
'GL_UNSIGNED_INT_SAMPLER_CUBE_EXT', 'GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT',
'GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT',
'GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT', 'GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT',
'GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT', 'GL_GEOMETRY_SHADER_EXT',
'GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT',
'GL_MAX_VERTEX_VARYING_COMPONENTS_EXT', 'GL_MAX_VARYING_COMPONENTS_EXT',
'GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT',
'GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT',
'GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT', 'GL_GEOMETRY_VERTICES_OUT_EXT',
'GL_GEOMETRY_INPUT_TYPE_EXT', 'GL_GEOMETRY_OUTPUT_TYPE_EXT',
'GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT', 'GL_LINES_ADJACENCY_EXT',
'GL_LINE_STRIP_ADJACENCY_EXT', 'GL_TRIANGLES_ADJACENCY_EXT',
'GL_TRIANGLE_STRIP_ADJACENCY_EXT', 'GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT', 'GL_PROGRAM_POINT_SIZE_EXT',
'GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT',
'GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT',
'GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT', 'GL_MAX_BINDABLE_UNIFORM_SIZE_EXT',
'GL_UNIFORM_BUFFER_EXT', 'GL_UNIFORM_BUFFER_BINDING_EXT',
'GL_FRAMEBUFFER_SRGB_EXT', 'GL_FRAMEBUFFER_SRGB_CAPABLE_EXT',
'GL_RGB9_E5_EXT', 'GL_UNSIGNED_INT_5_9_9_9_REV_EXT',
'GL_TEXTURE_SHARED_SIZE_EXT', 'GL_R11F_G11F_B10F_EXT',
'GL_UNSIGNED_INT_10F_11F_11F_REV_EXT', 'GL_RGBA_SIGNED_COMPONENTS_EXT',
'GL_TEXTURE_1D_ARRAY_EXT', 'GL_PROXY_TEXTURE_1D_ARRAY_EXT',
'GL_TEXTURE_2D_ARRAY_EXT', 'GL_PROXY_TEXTURE_2D_ARRAY_EXT',
'GL_TEXTURE_BINDING_1D_ARRAY_EXT', 'GL_TEXTURE_BINDING_2D_ARRAY_EXT',
'GL_MAX_ARRAY_TEXTURE_LAYERS_EXT', 'GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT',
'GL_RGBA32UI_EXT', 'GL_RGB32UI_EXT', 'GL_ALPHA32UI_EXT',
'GL_INTENSITY32UI_EXT', 'GL_LUMINANCE32UI_EXT', 'GL_LUMINANCE_ALPHA32UI_EXT',
'GL_RGBA16UI_EXT', 'GL_RGB16UI_EXT', 'GL_ALPHA16UI_EXT',
'GL_INTENSITY16UI_EXT', 'GL_LUMINANCE16UI_EXT', 'GL_LUMINANCE_ALPHA16UI_EXT',
'GL_RGBA8UI_EXT', 'GL_RGB8UI_EXT', 'GL_ALPHA8UI_EXT', 'GL_INTENSITY8UI_EXT',
'GL_LUMINANCE8UI_EXT', 'GL_LUMINANCE_ALPHA8UI_EXT', 'GL_RGBA32I_EXT',
'GL_RGB32I_EXT', 'GL_ALPHA32I_EXT', 'GL_INTENSITY32I_EXT',
'GL_LUMINANCE32I_EXT', 'GL_LUMINANCE_ALPHA32I_EXT', 'GL_RGBA16I_EXT',
'GL_RGB16I_EXT', 'GL_ALPHA16I_EXT', 'GL_INTENSITY16I_EXT',
'GL_LUMINANCE16I_EXT', 'GL_LUMINANCE_ALPHA16I_EXT', 'GL_RGBA8I_EXT',
'GL_RGB8I_EXT', 'GL_ALPHA8I_EXT', 'GL_INTENSITY8I_EXT', 'GL_LUMINANCE8I_EXT',
'GL_LUMINANCE_ALPHA8I_EXT', 'GL_RED_INTEGER_EXT', 'GL_GREEN_INTEGER_EXT',
'GL_BLUE_INTEGER_EXT', 'GL_ALPHA_INTEGER_EXT', 'GL_RGB_INTEGER_EXT',
'GL_RGBA_INTEGER_EXT', 'GL_BGR_INTEGER_EXT', 'GL_BGRA_INTEGER_EXT',
'GL_LUMINANCE_INTEGER_EXT', 'GL_LUMINANCE_ALPHA_INTEGER_EXT',
'GL_RGBA_INTEGER_MODE_EXT', 'GL_DEPTH_COMPONENT32F_NV',
'GL_DEPTH32F_STENCIL8_NV', 'GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV',
'GL_DEPTH_BUFFER_FLOAT_MODE_NV', 'GL_COMPRESSED_LUMINANCE_LATC1_EXT',
'GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT',
'GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT',
'GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT', 'GL_BACK_PRIMARY_COLOR_NV',
'GL_BACK_SECONDARY_COLOR_NV', 'GL_TEXTURE_COORD_NV', 'GL_CLIP_DISTANCE_NV',
'GL_VERTEX_ID_NV', 'GL_PRIMITIVE_ID_NV', 'GL_GENERIC_ATTRIB_NV',
'GL_TRANSFORM_FEEDBACK_ATTRIBS_NV', 'GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV', 'GL_ACTIVE_VARYINGS_NV',
'GL_ACTIVE_VARYING_MAX_LENGTH_NV', 'GL_TRANSFORM_FEEDBACK_VARYINGS_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_START_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV', 'GL_TRANSFORM_FEEDBACK_RECORD_NV',
'GL_PRIMITIVES_GENERATED_NV', 'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV',
'GL_RASTERIZER_DISCARD_NV',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV', 'GL_INTERLEAVED_ATTRIBS_NV',
'GL_SEPARATE_ATTRIBS_NV', 'GL_TRANSFORM_FEEDBACK_BUFFER_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV', 'GL_GEOMETRY_PROGRAM_NV',
'GL_MAX_PROGRAM_OUTPUT_VERTICES_NV',
'GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV', 'GL_MIN_PROGRAM_TEXEL_OFFSET_NV',
'GL_MAX_PROGRAM_TEXEL_OFFSET_NV', 'GL_PROGRAM_ATTRIB_COMPONENTS_NV',
'GL_PROGRAM_RESULT_COMPONENTS_NV', 'GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV',
'GL_MAX_PROGRAM_RESULT_COMPONENTS_NV', 'GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV',
'GL_MAX_PROGRAM_GENERIC_RESULTS_NV',
'GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV',
'GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV',
'GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV',
'GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV',
'GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV',
'GL_RENDERBUFFER_COVERAGE_SAMPLES_NV', 'GL_RENDERBUFFER_COLOR_SAMPLES_NV',
'GL_MAX_RENDERBUFFER_COVERAGE_SAMPLES_NV',
'GL_MAX_RENDERBUFFER_COLOR_SAMPLES_NV',
'GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV', 'GL_MULTISAMPLE_COVERAGE_MODES_NV',
'GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT', 'GL_MAX_SAMPLES_EXT',
'GL_RENDERBUFFER_SAMPLES_EXT', 'GL_READ_FRAMEBUFFER_EXT',
'GL_DRAW_FRAMEBUFFER_EXT', 'GL_DRAW_FRAMEBUFFER_BINDING_EXT',
'GL_READ_FRAMEBUFFER_BINDING_EXT', 'GL_COMPRESSED_RED_RGTC1_EXT',
'GL_COMPRESSED_SIGNED_RED_RGTC1_EXT', 'GL_COMPRESSED_RED_GREEN_RGTC2_EXT',
'GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT', 'GL_FRAME_NV', 'GL_FIELDS_NV',
'GL_CURRENT_TIME_NV', 'GL_NUM_FILL_STREAMS_NV', 'GL_PRESENT_TIME_NV',
'GL_PRESENT_DURATION_NV', 'GL_QUERY_WAIT_NV', 'GL_QUERY_NO_WAIT_NV',
'GL_QUERY_BY_REGION_WAIT_NV', 'GL_QUERY_BY_REGION_NO_WAIT_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_EXT', 'GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT', 'GL_INTERLEAVED_ATTRIBS_EXT',
'GL_SEPARATE_ATTRIBS_EXT', 'GL_PRIMITIVES_GENERATED_EXT',
'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT', 'GL_RASTERIZER_DISCARD_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT',
'GL_TRANSFORM_FEEDBACK_VARYINGS_EXT', 'GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT',
'GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT', 'GL_PROGRAM_MATRIX_EXT',
'GL_TRANSPOSE_PROGRAM_MATRIX_EXT', 'GL_PROGRAM_MATRIX_STACK_DEPTH_EXT',
'GL_TEXTURE_SWIZZLE_R_EXT', 'GL_TEXTURE_SWIZZLE_G_EXT',
'GL_TEXTURE_SWIZZLE_B_EXT', 'GL_TEXTURE_SWIZZLE_A_EXT',
'GL_TEXTURE_SWIZZLE_RGBA_EXT', 'GL_SAMPLE_POSITION_NV', 'GL_SAMPLE_MASK_NV',
'GL_SAMPLE_MASK_VALUE_NV', 'GL_TEXTURE_BINDING_RENDERBUFFER_NV',
'GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV',
'GL_MAX_SAMPLE_MASK_WORDS_NV', 'GL_TEXTURE_RENDERBUFFER_NV',
'GL_SAMPLER_RENDERBUFFER_NV', 'GL_INT_SAMPLER_RENDERBUFFER_NV',
'GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV', 'GL_TRANSFORM_FEEDBACK_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV', 'GL_TRANSFORM_FEEDBACK_BINDING_NV',
'GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV', 'GL_ELEMENT_ARRAY_UNIFIED_NV',
'GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV', 'GL_VERTEX_ARRAY_ADDRESS_NV',
'GL_NORMAL_ARRAY_ADDRESS_NV', 'GL_COLOR_ARRAY_ADDRESS_NV',
'GL_INDEX_ARRAY_ADDRESS_NV', 'GL_TEXTURE_COORD_ARRAY_ADDRESS_NV',
'GL_EDGE_FLAG_ARRAY_ADDRESS_NV', 'GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV',
'GL_FOG_COORD_ARRAY_ADDRESS_NV', 'GL_ELEMENT_ARRAY_ADDRESS_NV',
'GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV', 'GL_VERTEX_ARRAY_LENGTH_NV',
'GL_NORMAL_ARRAY_LENGTH_NV', 'GL_COLOR_ARRAY_LENGTH_NV',
'GL_INDEX_ARRAY_LENGTH_NV', 'GL_TEXTURE_COORD_ARRAY_LENGTH_NV',
'GL_EDGE_FLAG_ARRAY_LENGTH_NV', 'GL_SECONDARY_COLOR_ARRAY_LENGTH_NV',
'GL_FOG_COORD_ARRAY_LENGTH_NV', 'GL_ELEMENT_ARRAY_LENGTH_NV',
'GL_BUFFER_GPU_ADDRESS_NV', 'GL_GPU_ADDRESS_NV',
'GL_MAX_SHADER_BUFFER_ADDRESS_NV', 'GLchar', 'GLintptr', 'GLsizeiptr',
'GLintptrARB', 'GLsizeiptrARB', 'GLcharARB', 'GLhandleARB', 'GLhalfARB',
'GLhalfNV', 'GLint64EXT', 'GLuint64EXT', 'GL_VERSION_1_4',
'glBlendFuncSeparate', 'glFogCoordf', 'glFogCoordfv', 'glFogCoordd',
'glFogCoorddv', 'glFogCoordPointer', 'glMultiDrawArrays',
'glMultiDrawElements', 'glPointParameterf', 'glPointParameterfv',
'glPointParameteri', 'glPointParameteriv', 'glSecondaryColor3b',
'glSecondaryColor3bv', 'glSecondaryColor3d', 'glSecondaryColor3dv',
'glSecondaryColor3f', 'glSecondaryColor3fv', 'glSecondaryColor3i',
'glSecondaryColor3iv', 'glSecondaryColor3s', 'glSecondaryColor3sv',
'glSecondaryColor3ub', 'glSecondaryColor3ubv', 'glSecondaryColor3ui',
'glSecondaryColor3uiv', 'glSecondaryColor3us', 'glSecondaryColor3usv',
'glSecondaryColorPointer', 'glWindowPos2d', 'glWindowPos2dv', 'glWindowPos2f',
'glWindowPos2fv', 'glWindowPos2i', 'glWindowPos2iv', 'glWindowPos2s',
'glWindowPos2sv', 'glWindowPos3d', 'glWindowPos3dv', 'glWindowPos3f',
'glWindowPos3fv', 'glWindowPos3i', 'glWindowPos3iv', 'glWindowPos3s',
'glWindowPos3sv', 'PFNGLBLENDFUNCSEPARATEPROC', 'PFNGLFOGCOORDFPROC',
'PFNGLFOGCOORDFVPROC', 'PFNGLFOGCOORDDPROC', 'PFNGLFOGCOORDDVPROC',
'PFNGLFOGCOORDPOINTERPROC', 'PFNGLMULTIDRAWARRAYSPROC',
'PFNGLMULTIDRAWELEMENTSPROC', 'PFNGLPOINTPARAMETERFPROC',
'PFNGLPOINTPARAMETERFVPROC', 'PFNGLPOINTPARAMETERIPROC',
'PFNGLPOINTPARAMETERIVPROC', 'PFNGLSECONDARYCOLOR3BPROC',
'PFNGLSECONDARYCOLOR3BVPROC', 'PFNGLSECONDARYCOLOR3DPROC',
'PFNGLSECONDARYCOLOR3DVPROC', 'PFNGLSECONDARYCOLOR3FPROC',
'PFNGLSECONDARYCOLOR3FVPROC', 'PFNGLSECONDARYCOLOR3IPROC',
'PFNGLSECONDARYCOLOR3IVPROC', 'PFNGLSECONDARYCOLOR3SPROC',
'PFNGLSECONDARYCOLOR3SVPROC', 'PFNGLSECONDARYCOLOR3UBPROC',
'PFNGLSECONDARYCOLOR3UBVPROC', 'PFNGLSECONDARYCOLOR3UIPROC',
'PFNGLSECONDARYCOLOR3UIVPROC', 'PFNGLSECONDARYCOLOR3USPROC',
'PFNGLSECONDARYCOLOR3USVPROC', 'PFNGLSECONDARYCOLORPOINTERPROC',
'PFNGLWINDOWPOS2DPROC', 'PFNGLWINDOWPOS2DVPROC', 'PFNGLWINDOWPOS2FPROC',
'PFNGLWINDOWPOS2FVPROC', 'PFNGLWINDOWPOS2IPROC', 'PFNGLWINDOWPOS2IVPROC',
'PFNGLWINDOWPOS2SPROC', 'PFNGLWINDOWPOS2SVPROC', 'PFNGLWINDOWPOS3DPROC',
'PFNGLWINDOWPOS3DVPROC', 'PFNGLWINDOWPOS3FPROC', 'PFNGLWINDOWPOS3FVPROC',
'PFNGLWINDOWPOS3IPROC', 'PFNGLWINDOWPOS3IVPROC', 'PFNGLWINDOWPOS3SPROC',
'PFNGLWINDOWPOS3SVPROC', 'GL_VERSION_1_5', 'glGenQueries', 'glDeleteQueries',
'glIsQuery', 'glBeginQuery', 'glEndQuery', 'glGetQueryiv',
'glGetQueryObjectiv', 'glGetQueryObjectuiv', 'glBindBuffer',
'glDeleteBuffers', 'glGenBuffers', 'glIsBuffer', 'glBufferData',
'glBufferSubData', 'glGetBufferSubData', 'glMapBuffer', 'glUnmapBuffer',
'glGetBufferParameteriv', 'glGetBufferPointerv', 'PFNGLGENQUERIESPROC',
'PFNGLDELETEQUERIESPROC', 'PFNGLISQUERYPROC', 'PFNGLBEGINQUERYPROC',
'PFNGLENDQUERYPROC', 'PFNGLGETQUERYIVPROC', 'PFNGLGETQUERYOBJECTIVPROC',
'PFNGLGETQUERYOBJECTUIVPROC', 'PFNGLBINDBUFFERPROC', 'PFNGLDELETEBUFFERSPROC',
'PFNGLGENBUFFERSPROC', 'PFNGLISBUFFERPROC', 'PFNGLBUFFERDATAPROC',
'PFNGLBUFFERSUBDATAPROC', 'PFNGLGETBUFFERSUBDATAPROC', 'PFNGLMAPBUFFERPROC',
'PFNGLUNMAPBUFFERPROC', 'PFNGLGETBUFFERPARAMETERIVPROC',
'PFNGLGETBUFFERPOINTERVPROC', 'GL_VERSION_2_0', 'glBlendEquationSeparate',
'glDrawBuffers', 'glStencilOpSeparate', 'glStencilFuncSeparate',
'glStencilMaskSeparate', 'glAttachShader', 'glBindAttribLocation',
'glCompileShader', 'glCreateProgram', 'glCreateShader', 'glDeleteProgram',
'glDeleteShader', 'glDetachShader', 'glDisableVertexAttribArray',
'glEnableVertexAttribArray', 'glGetActiveAttrib', 'glGetActiveUniform',
'glGetAttachedShaders', 'glGetAttribLocation', 'glGetProgramiv',
'glGetProgramInfoLog', 'glGetShaderiv', 'glGetShaderInfoLog',
'glGetShaderSource', 'glGetUniformLocation', 'glGetUniformfv',
'glGetUniformiv', 'glGetVertexAttribdv', 'glGetVertexAttribfv',
'glGetVertexAttribiv', 'glGetVertexAttribPointerv', 'glIsProgram',
'glIsShader', 'glLinkProgram', 'glShaderSource', 'glUseProgram',
'glUniform1f', 'glUniform2f', 'glUniform3f', 'glUniform4f', 'glUniform1i',
'glUniform2i', 'glUniform3i', 'glUniform4i', 'glUniform1fv', 'glUniform2fv',
'glUniform3fv', 'glUniform4fv', 'glUniform1iv', 'glUniform2iv',
'glUniform3iv', 'glUniform4iv', 'glUniformMatrix2fv', 'glUniformMatrix3fv',
'glUniformMatrix4fv', 'glValidateProgram', 'glVertexAttrib1d',
'glVertexAttrib1dv', 'glVertexAttrib1f', 'glVertexAttrib1fv',
'glVertexAttrib1s', 'glVertexAttrib1sv', 'glVertexAttrib2d',
'glVertexAttrib2dv', 'glVertexAttrib2f', 'glVertexAttrib2fv',
'glVertexAttrib2s', 'glVertexAttrib2sv', 'glVertexAttrib3d',
'glVertexAttrib3dv', 'glVertexAttrib3f', 'glVertexAttrib3fv',
'glVertexAttrib3s', 'glVertexAttrib3sv', 'glVertexAttrib4Nbv',
'glVertexAttrib4Niv', 'glVertexAttrib4Nsv', 'glVertexAttrib4Nub',
'glVertexAttrib4Nubv', 'glVertexAttrib4Nuiv', 'glVertexAttrib4Nusv',
'glVertexAttrib4bv', 'glVertexAttrib4d', 'glVertexAttrib4dv',
'glVertexAttrib4f', 'glVertexAttrib4fv', 'glVertexAttrib4iv',
'glVertexAttrib4s', 'glVertexAttrib4sv', 'glVertexAttrib4ubv',
'glVertexAttrib4uiv', 'glVertexAttrib4usv', 'glVertexAttribPointer',
'PFNGLBLENDEQUATIONSEPARATEPROC', 'PFNGLDRAWBUFFERSPROC',
'PFNGLSTENCILOPSEPARATEPROC', 'PFNGLSTENCILFUNCSEPARATEPROC',
'PFNGLSTENCILMASKSEPARATEPROC', 'PFNGLATTACHSHADERPROC',
'PFNGLBINDATTRIBLOCATIONPROC', 'PFNGLCOMPILESHADERPROC',
'PFNGLCREATEPROGRAMPROC', 'PFNGLCREATESHADERPROC', 'PFNGLDELETEPROGRAMPROC',
'PFNGLDELETESHADERPROC', 'PFNGLDETACHSHADERPROC',
'PFNGLDISABLEVERTEXATTRIBARRAYPROC', 'PFNGLENABLEVERTEXATTRIBARRAYPROC',
'PFNGLGETACTIVEATTRIBPROC', 'PFNGLGETACTIVEUNIFORMPROC',
'PFNGLGETATTACHEDSHADERSPROC', 'PFNGLGETATTRIBLOCATIONPROC',
'PFNGLGETPROGRAMIVPROC', 'PFNGLGETPROGRAMINFOLOGPROC', 'PFNGLGETSHADERIVPROC',
'PFNGLGETSHADERINFOLOGPROC', 'PFNGLGETSHADERSOURCEPROC',
'PFNGLGETUNIFORMLOCATIONPROC', 'PFNGLGETUNIFORMFVPROC',
'PFNGLGETUNIFORMIVPROC', 'PFNGLGETVERTEXATTRIBDVPROC',
'PFNGLGETVERTEXATTRIBFVPROC', 'PFNGLGETVERTEXATTRIBIVPROC',
'PFNGLGETVERTEXATTRIBPOINTERVPROC', 'PFNGLISPROGRAMPROC', 'PFNGLISSHADERPROC',
'PFNGLLINKPROGRAMPROC', 'PFNGLSHADERSOURCEPROC', 'PFNGLUSEPROGRAMPROC',
'PFNGLUNIFORM1FPROC', 'PFNGLUNIFORM2FPROC', 'PFNGLUNIFORM3FPROC',
'PFNGLUNIFORM4FPROC', 'PFNGLUNIFORM1IPROC', 'PFNGLUNIFORM2IPROC',
'PFNGLUNIFORM3IPROC', 'PFNGLUNIFORM4IPROC', 'PFNGLUNIFORM1FVPROC',
'PFNGLUNIFORM2FVPROC', 'PFNGLUNIFORM3FVPROC', 'PFNGLUNIFORM4FVPROC',
'PFNGLUNIFORM1IVPROC', 'PFNGLUNIFORM2IVPROC', 'PFNGLUNIFORM3IVPROC',
'PFNGLUNIFORM4IVPROC', 'PFNGLUNIFORMMATRIX2FVPROC',
'PFNGLUNIFORMMATRIX3FVPROC', 'PFNGLUNIFORMMATRIX4FVPROC',
'PFNGLVALIDATEPROGRAMPROC', 'PFNGLVERTEXATTRIB1DPROC',
'PFNGLVERTEXATTRIB1DVPROC', 'PFNGLVERTEXATTRIB1FPROC',
'PFNGLVERTEXATTRIB1FVPROC', 'PFNGLVERTEXATTRIB1SPROC',
'PFNGLVERTEXATTRIB1SVPROC', 'PFNGLVERTEXATTRIB2DPROC',
'PFNGLVERTEXATTRIB2DVPROC', 'PFNGLVERTEXATTRIB2FPROC',
'PFNGLVERTEXATTRIB2FVPROC', 'PFNGLVERTEXATTRIB2SPROC',
'PFNGLVERTEXATTRIB2SVPROC', 'PFNGLVERTEXATTRIB3DPROC',
'PFNGLVERTEXATTRIB3DVPROC', 'PFNGLVERTEXATTRIB3FPROC',
'PFNGLVERTEXATTRIB3FVPROC', 'PFNGLVERTEXATTRIB3SPROC',
'PFNGLVERTEXATTRIB3SVPROC', 'PFNGLVERTEXATTRIB4NBVPROC',
'PFNGLVERTEXATTRIB4NIVPROC', 'PFNGLVERTEXATTRIB4NSVPROC',
'PFNGLVERTEXATTRIB4NUBPROC', 'PFNGLVERTEXATTRIB4NUBVPROC',
'PFNGLVERTEXATTRIB4NUIVPROC', 'PFNGLVERTEXATTRIB4NUSVPROC',
'PFNGLVERTEXATTRIB4BVPROC', 'PFNGLVERTEXATTRIB4DPROC',
'PFNGLVERTEXATTRIB4DVPROC', 'PFNGLVERTEXATTRIB4FPROC',
'PFNGLVERTEXATTRIB4FVPROC', 'PFNGLVERTEXATTRIB4IVPROC',
'PFNGLVERTEXATTRIB4SPROC', 'PFNGLVERTEXATTRIB4SVPROC',
'PFNGLVERTEXATTRIB4UBVPROC', 'PFNGLVERTEXATTRIB4UIVPROC',
'PFNGLVERTEXATTRIB4USVPROC', 'PFNGLVERTEXATTRIBPOINTERPROC', 'GL_VERSION_2_1',
'glUniformMatrix2x3fv', 'glUniformMatrix3x2fv', 'glUniformMatrix2x4fv',
'glUniformMatrix4x2fv', 'glUniformMatrix3x4fv', 'glUniformMatrix4x3fv',
'PFNGLUNIFORMMATRIX2X3FVPROC', 'PFNGLUNIFORMMATRIX3X2FVPROC',
'PFNGLUNIFORMMATRIX2X4FVPROC', 'PFNGLUNIFORMMATRIX4X2FVPROC',
'PFNGLUNIFORMMATRIX3X4FVPROC', 'PFNGLUNIFORMMATRIX4X3FVPROC',
'GL_VERSION_3_0', 'glColorMaski', 'glGetBooleani_v', 'glGetIntegeri_v',
'glEnablei', 'glDisablei', 'glIsEnabledi', 'glBeginTransformFeedback',
'glEndTransformFeedback', 'glBindBufferRange', 'glBindBufferBase',
'glTransformFeedbackVaryings', 'glGetTransformFeedbackVarying',
'glClampColor', 'glBeginConditionalRender', 'glEndConditionalRender',
'glVertexAttribI1i', 'glVertexAttribI2i', 'glVertexAttribI3i',
'glVertexAttribI4i', 'glVertexAttribI1ui', 'glVertexAttribI2ui',
'glVertexAttribI3ui', 'glVertexAttribI4ui', 'glVertexAttribI1iv',
'glVertexAttribI2iv', 'glVertexAttribI3iv', 'glVertexAttribI4iv',
'glVertexAttribI1uiv', 'glVertexAttribI2uiv', 'glVertexAttribI3uiv',
'glVertexAttribI4uiv', 'glVertexAttribI4bv', 'glVertexAttribI4sv',
'glVertexAttribI4ubv', 'glVertexAttribI4usv', 'glVertexAttribIPointer',
'glGetVertexAttribIiv', 'glGetVertexAttribIuiv', 'glGetUniformuiv',
'glBindFragDataLocation', 'glGetFragDataLocation', 'glUniform1ui',
'glUniform2ui', 'glUniform3ui', 'glUniform4ui', 'glUniform1uiv',
'glUniform2uiv', 'glUniform3uiv', 'glUniform4uiv', 'glTexParameterIiv',
'glTexParameterIuiv', 'glGetTexParameterIiv', 'glGetTexParameterIuiv',
'glClearBufferiv', 'glClearBufferuiv', 'glClearBufferfv', 'glClearBufferfi',
'glGetStringi', 'PFNGLCOLORMASKIPROC', 'PFNGLGETBOOLEANI_VPROC',
'PFNGLGETINTEGERI_VPROC', 'PFNGLENABLEIPROC', 'PFNGLDISABLEIPROC',
'PFNGLISENABLEDIPROC', 'PFNGLBEGINTRANSFORMFEEDBACKPROC',
'PFNGLENDTRANSFORMFEEDBACKPROC', 'PFNGLBINDBUFFERRANGEPROC',
'PFNGLBINDBUFFERBASEPROC', 'PFNGLTRANSFORMFEEDBACKVARYINGSPROC',
'PFNGLGETTRANSFORMFEEDBACKVARYINGPROC', 'PFNGLCLAMPCOLORPROC',
'PFNGLBEGINCONDITIONALRENDERPROC', 'PFNGLENDCONDITIONALRENDERPROC',
'PFNGLVERTEXATTRIBI1IPROC', 'PFNGLVERTEXATTRIBI2IPROC',
'PFNGLVERTEXATTRIBI3IPROC', 'PFNGLVERTEXATTRIBI4IPROC',
'PFNGLVERTEXATTRIBI1UIPROC', 'PFNGLVERTEXATTRIBI2UIPROC',
'PFNGLVERTEXATTRIBI3UIPROC', 'PFNGLVERTEXATTRIBI4UIPROC',
'PFNGLVERTEXATTRIBI1IVPROC', 'PFNGLVERTEXATTRIBI2IVPROC',
'PFNGLVERTEXATTRIBI3IVPROC', 'PFNGLVERTEXATTRIBI4IVPROC',
'PFNGLVERTEXATTRIBI1UIVPROC', 'PFNGLVERTEXATTRIBI2UIVPROC',
'PFNGLVERTEXATTRIBI3UIVPROC', 'PFNGLVERTEXATTRIBI4UIVPROC',
'PFNGLVERTEXATTRIBI4BVPROC', 'PFNGLVERTEXATTRIBI4SVPROC',
'PFNGLVERTEXATTRIBI4UBVPROC', 'PFNGLVERTEXATTRIBI4USVPROC',
'PFNGLVERTEXATTRIBIPOINTERPROC', 'PFNGLGETVERTEXATTRIBIIVPROC',
'PFNGLGETVERTEXATTRIBIUIVPROC', 'PFNGLGETUNIFORMUIVPROC',
'PFNGLBINDFRAGDATALOCATIONPROC', 'PFNGLGETFRAGDATALOCATIONPROC',
'PFNGLUNIFORM1UIPROC', 'PFNGLUNIFORM2UIPROC', 'PFNGLUNIFORM3UIPROC',
'PFNGLUNIFORM4UIPROC', 'PFNGLUNIFORM1UIVPROC', 'PFNGLUNIFORM2UIVPROC',
'PFNGLUNIFORM3UIVPROC', 'PFNGLUNIFORM4UIVPROC', 'PFNGLTEXPARAMETERIIVPROC',
'PFNGLTEXPARAMETERIUIVPROC', 'PFNGLGETTEXPARAMETERIIVPROC',
'PFNGLGETTEXPARAMETERIUIVPROC', 'PFNGLCLEARBUFFERIVPROC',
'PFNGLCLEARBUFFERUIVPROC', 'PFNGLCLEARBUFFERFVPROC', 'PFNGLCLEARBUFFERFIPROC',
'PFNGLGETSTRINGIPROC', 'GL_ARB_transpose_matrix', 'glLoadTransposeMatrixfARB',
'glLoadTransposeMatrixdARB', 'glMultTransposeMatrixfARB',
'glMultTransposeMatrixdARB', 'PFNGLLOADTRANSPOSEMATRIXFARBPROC',
'PFNGLLOADTRANSPOSEMATRIXDARBPROC', 'PFNGLMULTTRANSPOSEMATRIXFARBPROC',
'PFNGLMULTTRANSPOSEMATRIXDARBPROC', 'GL_ARB_multisample',
'glSampleCoverageARB', 'PFNGLSAMPLECOVERAGEARBPROC', 'GL_ARB_texture_env_add',
'GL_ARB_texture_cube_map', 'GL_ARB_texture_compression',
'glCompressedTexImage3DARB', 'glCompressedTexImage2DARB',
'glCompressedTexImage1DARB', 'glCompressedTexSubImage3DARB',
'glCompressedTexSubImage2DARB', 'glCompressedTexSubImage1DARB',
'glGetCompressedTexImageARB', 'PFNGLCOMPRESSEDTEXIMAGE3DARBPROC',
'PFNGLCOMPRESSEDTEXIMAGE2DARBPROC', 'PFNGLCOMPRESSEDTEXIMAGE1DARBPROC',
'PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC', 'PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC',
'PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC', 'PFNGLGETCOMPRESSEDTEXIMAGEARBPROC',
'GL_ARB_texture_border_clamp', 'GL_ARB_point_parameters',
'glPointParameterfARB', 'glPointParameterfvARB',
'PFNGLPOINTPARAMETERFARBPROC', 'PFNGLPOINTPARAMETERFVARBPROC',
'GL_ARB_vertex_blend', 'glWeightbvARB', 'glWeightsvARB', 'glWeightivARB',
'glWeightfvARB', 'glWeightdvARB', 'glWeightubvARB', 'glWeightusvARB',
'glWeightuivARB', 'glWeightPointerARB', 'glVertexBlendARB',
'PFNGLWEIGHTBVARBPROC', 'PFNGLWEIGHTSVARBPROC', 'PFNGLWEIGHTIVARBPROC',
'PFNGLWEIGHTFVARBPROC', 'PFNGLWEIGHTDVARBPROC', 'PFNGLWEIGHTUBVARBPROC',
'PFNGLWEIGHTUSVARBPROC', 'PFNGLWEIGHTUIVARBPROC', 'PFNGLWEIGHTPOINTERARBPROC',
'PFNGLVERTEXBLENDARBPROC', 'GL_ARB_matrix_palette',
'glCurrentPaletteMatrixARB', 'glMatrixIndexubvARB', 'glMatrixIndexusvARB',
'glMatrixIndexuivARB', 'glMatrixIndexPointerARB',
'PFNGLCURRENTPALETTEMATRIXARBPROC', 'PFNGLMATRIXINDEXUBVARBPROC',
'PFNGLMATRIXINDEXUSVARBPROC', 'PFNGLMATRIXINDEXUIVARBPROC',
'PFNGLMATRIXINDEXPOINTERARBPROC', 'GL_ARB_texture_env_combine',
'GL_ARB_texture_env_crossbar', 'GL_ARB_texture_env_dot3',
'GL_ARB_texture_mirrored_repeat', 'GL_ARB_depth_texture', 'GL_ARB_shadow',
'GL_ARB_shadow_ambient', 'GL_ARB_window_pos', 'glWindowPos2dARB',
'glWindowPos2dvARB', 'glWindowPos2fARB', 'glWindowPos2fvARB',
'glWindowPos2iARB', 'glWindowPos2ivARB', 'glWindowPos2sARB',
'glWindowPos2svARB', 'glWindowPos3dARB', 'glWindowPos3dvARB',
'glWindowPos3fARB', 'glWindowPos3fvARB', 'glWindowPos3iARB',
'glWindowPos3ivARB', 'glWindowPos3sARB', 'glWindowPos3svARB',
'PFNGLWINDOWPOS2DARBPROC', 'PFNGLWINDOWPOS2DVARBPROC',
'PFNGLWINDOWPOS2FARBPROC', 'PFNGLWINDOWPOS2FVARBPROC',
'PFNGLWINDOWPOS2IARBPROC', 'PFNGLWINDOWPOS2IVARBPROC',
'PFNGLWINDOWPOS2SARBPROC', 'PFNGLWINDOWPOS2SVARBPROC',
'PFNGLWINDOWPOS3DARBPROC', 'PFNGLWINDOWPOS3DVARBPROC',
'PFNGLWINDOWPOS3FARBPROC', 'PFNGLWINDOWPOS3FVARBPROC',
'PFNGLWINDOWPOS3IARBPROC', 'PFNGLWINDOWPOS3IVARBPROC',
'PFNGLWINDOWPOS3SARBPROC', 'PFNGLWINDOWPOS3SVARBPROC',
'GL_ARB_vertex_program', 'glVertexAttrib1dARB', 'glVertexAttrib1dvARB',
'glVertexAttrib1fARB', 'glVertexAttrib1fvARB', 'glVertexAttrib1sARB',
'glVertexAttrib1svARB', 'glVertexAttrib2dARB', 'glVertexAttrib2dvARB',
'glVertexAttrib2fARB', 'glVertexAttrib2fvARB', 'glVertexAttrib2sARB',
'glVertexAttrib2svARB', 'glVertexAttrib3dARB', 'glVertexAttrib3dvARB',
'glVertexAttrib3fARB', 'glVertexAttrib3fvARB', 'glVertexAttrib3sARB',
'glVertexAttrib3svARB', 'glVertexAttrib4NbvARB', 'glVertexAttrib4NivARB',
'glVertexAttrib4NsvARB', 'glVertexAttrib4NubARB', 'glVertexAttrib4NubvARB',
'glVertexAttrib4NuivARB', 'glVertexAttrib4NusvARB', 'glVertexAttrib4bvARB',
'glVertexAttrib4dARB', 'glVertexAttrib4dvARB', 'glVertexAttrib4fARB',
'glVertexAttrib4fvARB', 'glVertexAttrib4ivARB', 'glVertexAttrib4sARB',
'glVertexAttrib4svARB', 'glVertexAttrib4ubvARB', 'glVertexAttrib4uivARB',
'glVertexAttrib4usvARB', 'glVertexAttribPointerARB',
'glEnableVertexAttribArrayARB', 'glDisableVertexAttribArrayARB',
'glProgramStringARB', 'glBindProgramARB', 'glDeleteProgramsARB',
'glGenProgramsARB', 'glProgramEnvParameter4dARB',
'glProgramEnvParameter4dvARB', 'glProgramEnvParameter4fARB',
'glProgramEnvParameter4fvARB', 'glProgramLocalParameter4dARB',
'glProgramLocalParameter4dvARB', 'glProgramLocalParameter4fARB',
'glProgramLocalParameter4fvARB', 'glGetProgramEnvParameterdvARB',
'glGetProgramEnvParameterfvARB', 'glGetProgramLocalParameterdvARB',
'glGetProgramLocalParameterfvARB', 'glGetProgramivARB',
'glGetProgramStringARB', 'glGetVertexAttribdvARB', 'glGetVertexAttribfvARB',
'glGetVertexAttribivARB', 'glGetVertexAttribPointervARB', 'glIsProgramARB',
'PFNGLVERTEXATTRIB1DARBPROC', 'PFNGLVERTEXATTRIB1DVARBPROC',
'PFNGLVERTEXATTRIB1FARBPROC', 'PFNGLVERTEXATTRIB1FVARBPROC',
'PFNGLVERTEXATTRIB1SARBPROC', 'PFNGLVERTEXATTRIB1SVARBPROC',
'PFNGLVERTEXATTRIB2DARBPROC', 'PFNGLVERTEXATTRIB2DVARBPROC',
'PFNGLVERTEXATTRIB2FARBPROC', 'PFNGLVERTEXATTRIB2FVARBPROC',
'PFNGLVERTEXATTRIB2SARBPROC', 'PFNGLVERTEXATTRIB2SVARBPROC',
'PFNGLVERTEXATTRIB3DARBPROC', 'PFNGLVERTEXATTRIB3DVARBPROC',
'PFNGLVERTEXATTRIB3FARBPROC', 'PFNGLVERTEXATTRIB3FVARBPROC',
'PFNGLVERTEXATTRIB3SARBPROC', 'PFNGLVERTEXATTRIB3SVARBPROC',
'PFNGLVERTEXATTRIB4NBVARBPROC', 'PFNGLVERTEXATTRIB4NIVARBPROC',
'PFNGLVERTEXATTRIB4NSVARBPROC', 'PFNGLVERTEXATTRIB4NUBARBPROC',
'PFNGLVERTEXATTRIB4NUBVARBPROC', 'PFNGLVERTEXATTRIB4NUIVARBPROC',
'PFNGLVERTEXATTRIB4NUSVARBPROC', 'PFNGLVERTEXATTRIB4BVARBPROC',
'PFNGLVERTEXATTRIB4DARBPROC', 'PFNGLVERTEXATTRIB4DVARBPROC',
'PFNGLVERTEXATTRIB4FARBPROC', 'PFNGLVERTEXATTRIB4FVARBPROC',
'PFNGLVERTEXATTRIB4IVARBPROC', 'PFNGLVERTEXATTRIB4SARBPROC',
'PFNGLVERTEXATTRIB4SVARBPROC', 'PFNGLVERTEXATTRIB4UBVARBPROC',
'PFNGLVERTEXATTRIB4UIVARBPROC', 'PFNGLVERTEXATTRIB4USVARBPROC',
'PFNGLVERTEXATTRIBPOINTERARBPROC', 'PFNGLENABLEVERTEXATTRIBARRAYARBPROC',
'PFNGLDISABLEVERTEXATTRIBARRAYARBPROC', 'PFNGLPROGRAMSTRINGARBPROC',
'PFNGLBINDPROGRAMARBPROC', 'PFNGLDELETEPROGRAMSARBPROC',
'PFNGLGENPROGRAMSARBPROC', 'PFNGLPROGRAMENVPARAMETER4DARBPROC',
'PFNGLPROGRAMENVPARAMETER4DVARBPROC', 'PFNGLPROGRAMENVPARAMETER4FARBPROC',
'PFNGLPROGRAMENVPARAMETER4FVARBPROC', 'PFNGLPROGRAMLOCALPARAMETER4DARBPROC',
'PFNGLPROGRAMLOCALPARAMETER4DVARBPROC', 'PFNGLPROGRAMLOCALPARAMETER4FARBPROC',
'PFNGLPROGRAMLOCALPARAMETER4FVARBPROC',
'PFNGLGETPROGRAMENVPARAMETERDVARBPROC',
'PFNGLGETPROGRAMENVPARAMETERFVARBPROC',
'PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC',
'PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC', 'PFNGLGETPROGRAMIVARBPROC',
'PFNGLGETPROGRAMSTRINGARBPROC', 'PFNGLGETVERTEXATTRIBDVARBPROC',
'PFNGLGETVERTEXATTRIBFVARBPROC', 'PFNGLGETVERTEXATTRIBIVARBPROC',
'PFNGLGETVERTEXATTRIBPOINTERVARBPROC', 'PFNGLISPROGRAMARBPROC',
'GL_ARB_fragment_program', 'GL_ARB_vertex_buffer_object', 'glBindBufferARB',
'glDeleteBuffersARB', 'glGenBuffersARB', 'glIsBufferARB', 'glBufferDataARB',
'glBufferSubDataARB', 'glGetBufferSubDataARB', 'glMapBufferARB',
'glUnmapBufferARB', 'glGetBufferParameterivARB', 'glGetBufferPointervARB',
'PFNGLBINDBUFFERARBPROC', 'PFNGLDELETEBUFFERSARBPROC',
'PFNGLGENBUFFERSARBPROC', 'PFNGLISBUFFERARBPROC', 'PFNGLBUFFERDATAARBPROC',
'PFNGLBUFFERSUBDATAARBPROC', 'PFNGLGETBUFFERSUBDATAARBPROC',
'PFNGLMAPBUFFERARBPROC', 'PFNGLUNMAPBUFFERARBPROC',
'PFNGLGETBUFFERPARAMETERIVARBPROC', 'PFNGLGETBUFFERPOINTERVARBPROC',
'GL_ARB_occlusion_query', 'glGenQueriesARB', 'glDeleteQueriesARB',
'glIsQueryARB', 'glBeginQueryARB', 'glEndQueryARB', 'glGetQueryivARB',
'glGetQueryObjectivARB', 'glGetQueryObjectuivARB', 'PFNGLGENQUERIESARBPROC',
'PFNGLDELETEQUERIESARBPROC', 'PFNGLISQUERYARBPROC', 'PFNGLBEGINQUERYARBPROC',
'PFNGLENDQUERYARBPROC', 'PFNGLGETQUERYIVARBPROC',
'PFNGLGETQUERYOBJECTIVARBPROC', 'PFNGLGETQUERYOBJECTUIVARBPROC',
'GL_ARB_shader_objects', 'glDeleteObjectARB', 'glGetHandleARB',
'glDetachObjectARB', 'glCreateShaderObjectARB', 'glShaderSourceARB',
'glCompileShaderARB', 'glCreateProgramObjectARB', 'glAttachObjectARB',
'glLinkProgramARB', 'glUseProgramObjectARB', 'glValidateProgramARB',
'glUniform1fARB', 'glUniform2fARB', 'glUniform3fARB', 'glUniform4fARB',
'glUniform1iARB', 'glUniform2iARB', 'glUniform3iARB', 'glUniform4iARB',
'glUniform1fvARB', 'glUniform2fvARB', 'glUniform3fvARB', 'glUniform4fvARB',
'glUniform1ivARB', 'glUniform2ivARB', 'glUniform3ivARB', 'glUniform4ivARB',
'glUniformMatrix2fvARB', 'glUniformMatrix3fvARB', 'glUniformMatrix4fvARB',
'glGetObjectParameterfvARB', 'glGetObjectParameterivARB', 'glGetInfoLogARB',
'glGetAttachedObjectsARB', 'glGetUniformLocationARB', 'glGetActiveUniformARB',
'glGetUniformfvARB', 'glGetUniformivARB', 'glGetShaderSourceARB',
'PFNGLDELETEOBJECTARBPROC', 'PFNGLGETHANDLEARBPROC',
'PFNGLDETACHOBJECTARBPROC', 'PFNGLCREATESHADEROBJECTARBPROC',
'PFNGLSHADERSOURCEARBPROC', 'PFNGLCOMPILESHADERARBPROC',
'PFNGLCREATEPROGRAMOBJECTARBPROC', 'PFNGLATTACHOBJECTARBPROC',
'PFNGLLINKPROGRAMARBPROC', 'PFNGLUSEPROGRAMOBJECTARBPROC',
'PFNGLVALIDATEPROGRAMARBPROC', 'PFNGLUNIFORM1FARBPROC',
'PFNGLUNIFORM2FARBPROC', 'PFNGLUNIFORM3FARBPROC', 'PFNGLUNIFORM4FARBPROC',
'PFNGLUNIFORM1IARBPROC', 'PFNGLUNIFORM2IARBPROC', 'PFNGLUNIFORM3IARBPROC',
'PFNGLUNIFORM4IARBPROC', 'PFNGLUNIFORM1FVARBPROC', 'PFNGLUNIFORM2FVARBPROC',
'PFNGLUNIFORM3FVARBPROC', 'PFNGLUNIFORM4FVARBPROC', 'PFNGLUNIFORM1IVARBPROC',
'PFNGLUNIFORM2IVARBPROC', 'PFNGLUNIFORM3IVARBPROC', 'PFNGLUNIFORM4IVARBPROC',
'PFNGLUNIFORMMATRIX2FVARBPROC', 'PFNGLUNIFORMMATRIX3FVARBPROC',
'PFNGLUNIFORMMATRIX4FVARBPROC', 'PFNGLGETOBJECTPARAMETERFVARBPROC',
'PFNGLGETOBJECTPARAMETERIVARBPROC', 'PFNGLGETINFOLOGARBPROC',
'PFNGLGETATTACHEDOBJECTSARBPROC', 'PFNGLGETUNIFORMLOCATIONARBPROC',
'PFNGLGETACTIVEUNIFORMARBPROC', 'PFNGLGETUNIFORMFVARBPROC',
'PFNGLGETUNIFORMIVARBPROC', 'PFNGLGETSHADERSOURCEARBPROC',
'GL_ARB_vertex_shader', 'glBindAttribLocationARB', 'glGetActiveAttribARB',
'glGetAttribLocationARB', 'PFNGLBINDATTRIBLOCATIONARBPROC',
'PFNGLGETACTIVEATTRIBARBPROC', 'PFNGLGETATTRIBLOCATIONARBPROC',
'GL_ARB_fragment_shader', 'GL_ARB_shading_language_100',
'GL_ARB_texture_non_power_of_two', 'GL_ARB_point_sprite',
'GL_ARB_fragment_program_shadow', 'GL_ARB_draw_buffers', 'glDrawBuffersARB',
'PFNGLDRAWBUFFERSARBPROC', 'GL_ARB_texture_rectangle',
'GL_ARB_color_buffer_float', 'glClampColorARB', 'PFNGLCLAMPCOLORARBPROC',
'GL_ARB_half_float_pixel', 'GL_ARB_texture_float',
'GL_ARB_pixel_buffer_object', 'GL_ARB_depth_buffer_float',
'GL_ARB_draw_instanced', 'glDrawArraysInstancedARB',
'glDrawElementsInstancedARB', 'PFNGLDRAWARRAYSINSTANCEDARBPROC',
'PFNGLDRAWELEMENTSINSTANCEDARBPROC', 'GL_ARB_framebuffer_object',
'glIsRenderbuffer', 'glBindRenderbuffer', 'glDeleteRenderbuffers',
'glGenRenderbuffers', 'glRenderbufferStorage', 'glGetRenderbufferParameteriv',
'glIsFramebuffer', 'glBindFramebuffer', 'glDeleteFramebuffers',
'glGenFramebuffers', 'glCheckFramebufferStatus', 'glFramebufferTexture1D',
'glFramebufferTexture2D', 'glFramebufferTexture3D',
'glFramebufferRenderbuffer', 'glGetFramebufferAttachmentParameteriv',
'glGenerateMipmap', 'glBlitFramebuffer', 'glRenderbufferStorageMultisample',
'glFramebufferTextureLayer', 'PFNGLISRENDERBUFFERPROC',
'PFNGLBINDRENDERBUFFERPROC', 'PFNGLDELETERENDERBUFFERSPROC',
'PFNGLGENRENDERBUFFERSPROC', 'PFNGLRENDERBUFFERSTORAGEPROC',
'PFNGLGETRENDERBUFFERPARAMETERIVPROC', 'PFNGLISFRAMEBUFFERPROC',
'PFNGLBINDFRAMEBUFFERPROC', 'PFNGLDELETEFRAMEBUFFERSPROC',
'PFNGLGENFRAMEBUFFERSPROC', 'PFNGLCHECKFRAMEBUFFERSTATUSPROC',
'PFNGLFRAMEBUFFERTEXTURE1DPROC', 'PFNGLFRAMEBUFFERTEXTURE2DPROC',
'PFNGLFRAMEBUFFERTEXTURE3DPROC', 'PFNGLFRAMEBUFFERRENDERBUFFERPROC',
'PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC', 'PFNGLGENERATEMIPMAPPROC',
'PFNGLBLITFRAMEBUFFERPROC', 'PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC',
'PFNGLFRAMEBUFFERTEXTURELAYERPROC', 'GL_ARB_framebuffer_sRGB',
'GL_ARB_geometry_shader4', 'glProgramParameteriARB',
'glFramebufferTextureARB', 'glFramebufferTextureLayerARB',
'glFramebufferTextureFaceARB', 'PFNGLPROGRAMPARAMETERIARBPROC',
'PFNGLFRAMEBUFFERTEXTUREARBPROC', 'PFNGLFRAMEBUFFERTEXTURELAYERARBPROC',
'PFNGLFRAMEBUFFERTEXTUREFACEARBPROC', 'GL_ARB_half_float_vertex',
'GL_ARB_instanced_arrays', 'glVertexAttribDivisorARB',
'PFNGLVERTEXATTRIBDIVISORARBPROC', 'GL_ARB_map_buffer_range',
'glMapBufferRange', 'glFlushMappedBufferRange', 'PFNGLMAPBUFFERRANGEPROC',
'PFNGLFLUSHMAPPEDBUFFERRANGEPROC', 'GL_ARB_texture_buffer_object',
'glTexBufferARB', 'PFNGLTEXBUFFERARBPROC', 'GL_ARB_texture_compression_rgtc',
'GL_ARB_texture_rg', 'GL_ARB_vertex_array_object', 'glBindVertexArray',
'glDeleteVertexArrays', 'glGenVertexArrays', 'glIsVertexArray',
'PFNGLBINDVERTEXARRAYPROC', 'PFNGLDELETEVERTEXARRAYSPROC',
'PFNGLGENVERTEXARRAYSPROC', 'PFNGLISVERTEXARRAYPROC', 'GL_EXT_abgr',
'GL_EXT_blend_color', 'glBlendColorEXT', 'PFNGLBLENDCOLOREXTPROC',
'GL_EXT_polygon_offset', 'glPolygonOffsetEXT', 'PFNGLPOLYGONOFFSETEXTPROC',
'GL_EXT_texture', 'GL_EXT_texture3D', 'glTexImage3DEXT', 'glTexSubImage3DEXT',
'PFNGLTEXIMAGE3DEXTPROC', 'PFNGLTEXSUBIMAGE3DEXTPROC',
'GL_SGIS_texture_filter4', 'glGetTexFilterFuncSGIS', 'glTexFilterFuncSGIS',
'PFNGLGETTEXFILTERFUNCSGISPROC', 'PFNGLTEXFILTERFUNCSGISPROC',
'GL_EXT_subtexture', 'glTexSubImage1DEXT', 'glTexSubImage2DEXT',
'PFNGLTEXSUBIMAGE1DEXTPROC', 'PFNGLTEXSUBIMAGE2DEXTPROC',
'GL_EXT_copy_texture', 'glCopyTexImage1DEXT', 'glCopyTexImage2DEXT',
'glCopyTexSubImage1DEXT', 'glCopyTexSubImage2DEXT', 'glCopyTexSubImage3DEXT',
'PFNGLCOPYTEXIMAGE1DEXTPROC', 'PFNGLCOPYTEXIMAGE2DEXTPROC',
'PFNGLCOPYTEXSUBIMAGE1DEXTPROC', 'PFNGLCOPYTEXSUBIMAGE2DEXTPROC',
'PFNGLCOPYTEXSUBIMAGE3DEXTPROC', 'GL_EXT_histogram', 'glGetHistogramEXT',
'glGetHistogramParameterfvEXT', 'glGetHistogramParameterivEXT',
'glGetMinmaxEXT', 'glGetMinmaxParameterfvEXT', 'glGetMinmaxParameterivEXT',
'glHistogramEXT', 'glMinmaxEXT', 'glResetHistogramEXT', 'glResetMinmaxEXT',
'PFNGLGETHISTOGRAMEXTPROC', 'PFNGLGETHISTOGRAMPARAMETERFVEXTPROC',
'PFNGLGETHISTOGRAMPARAMETERIVEXTPROC', 'PFNGLGETMINMAXEXTPROC',
'PFNGLGETMINMAXPARAMETERFVEXTPROC', 'PFNGLGETMINMAXPARAMETERIVEXTPROC',
'PFNGLHISTOGRAMEXTPROC', 'PFNGLMINMAXEXTPROC', 'PFNGLRESETHISTOGRAMEXTPROC',
'PFNGLRESETMINMAXEXTPROC', 'GL_EXT_convolution', 'glConvolutionFilter1DEXT',
'glConvolutionFilter2DEXT', 'glConvolutionParameterfEXT',
'glConvolutionParameterfvEXT', 'glConvolutionParameteriEXT',
'glConvolutionParameterivEXT', 'glCopyConvolutionFilter1DEXT',
'glCopyConvolutionFilter2DEXT', 'glGetConvolutionFilterEXT',
'glGetConvolutionParameterfvEXT', 'glGetConvolutionParameterivEXT',
'glGetSeparableFilterEXT', 'glSeparableFilter2DEXT',
'PFNGLCONVOLUTIONFILTER1DEXTPROC', 'PFNGLCONVOLUTIONFILTER2DEXTPROC',
'PFNGLCONVOLUTIONPARAMETERFEXTPROC', 'PFNGLCONVOLUTIONPARAMETERFVEXTPROC',
'PFNGLCONVOLUTIONPARAMETERIEXTPROC', 'PFNGLCONVOLUTIONPARAMETERIVEXTPROC',
'PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC', 'PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC',
'PFNGLGETCONVOLUTIONFILTEREXTPROC', 'PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC',
'PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC', 'PFNGLGETSEPARABLEFILTEREXTPROC',
'PFNGLSEPARABLEFILTER2DEXTPROC', 'GL_EXT_color_matrix', 'GL_SGI_color_table',
'glColorTableSGI', 'glColorTableParameterfvSGI', 'glColorTableParameterivSGI',
'glCopyColorTableSGI', 'glGetColorTableSGI', 'glGetColorTableParameterfvSGI',
'glGetColorTableParameterivSGI', 'PFNGLCOLORTABLESGIPROC',
'PFNGLCOLORTABLEPARAMETERFVSGIPROC', 'PFNGLCOLORTABLEPARAMETERIVSGIPROC',
'PFNGLCOPYCOLORTABLESGIPROC', 'PFNGLGETCOLORTABLESGIPROC',
'PFNGLGETCOLORTABLEPARAMETERFVSGIPROC',
'PFNGLGETCOLORTABLEPARAMETERIVSGIPROC', 'GL_SGIX_pixel_texture',
'glPixelTexGenSGIX', 'PFNGLPIXELTEXGENSGIXPROC', 'GL_SGIS_pixel_texture',
'glPixelTexGenParameteriSGIS', 'glPixelTexGenParameterivSGIS',
'glPixelTexGenParameterfSGIS', 'glPixelTexGenParameterfvSGIS',
'glGetPixelTexGenParameterivSGIS', 'glGetPixelTexGenParameterfvSGIS',
'PFNGLPIXELTEXGENPARAMETERISGISPROC', 'PFNGLPIXELTEXGENPARAMETERIVSGISPROC',
'PFNGLPIXELTEXGENPARAMETERFSGISPROC', 'PFNGLPIXELTEXGENPARAMETERFVSGISPROC',
'PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC',
'PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC', 'GL_SGIS_texture4D',
'glTexImage4DSGIS', 'glTexSubImage4DSGIS', 'PFNGLTEXIMAGE4DSGISPROC',
'PFNGLTEXSUBIMAGE4DSGISPROC', 'GL_SGI_texture_color_table', 'GL_EXT_cmyka',
'GL_EXT_texture_object', 'glAreTexturesResidentEXT', 'glBindTextureEXT',
'glDeleteTexturesEXT', 'glGenTexturesEXT', 'glIsTextureEXT',
'glPrioritizeTexturesEXT', 'PFNGLARETEXTURESRESIDENTEXTPROC',
'PFNGLBINDTEXTUREEXTPROC', 'PFNGLDELETETEXTURESEXTPROC',
'PFNGLGENTEXTURESEXTPROC', 'PFNGLISTEXTUREEXTPROC',
'PFNGLPRIORITIZETEXTURESEXTPROC', 'GL_SGIS_detail_texture',
'glDetailTexFuncSGIS', 'glGetDetailTexFuncSGIS', 'PFNGLDETAILTEXFUNCSGISPROC',
'PFNGLGETDETAILTEXFUNCSGISPROC', 'GL_SGIS_sharpen_texture',
'glSharpenTexFuncSGIS', 'glGetSharpenTexFuncSGIS',
'PFNGLSHARPENTEXFUNCSGISPROC', 'PFNGLGETSHARPENTEXFUNCSGISPROC',
'GL_EXT_packed_pixels', 'GL_SGIS_texture_lod', 'GL_SGIS_multisample',
'glSampleMaskSGIS', 'glSamplePatternSGIS', 'PFNGLSAMPLEMASKSGISPROC',
'PFNGLSAMPLEPATTERNSGISPROC', 'GL_EXT_rescale_normal', 'GL_EXT_vertex_array',
'glArrayElementEXT', 'glColorPointerEXT', 'glDrawArraysEXT',
'glEdgeFlagPointerEXT', 'glGetPointervEXT', 'glIndexPointerEXT',
'glNormalPointerEXT', 'glTexCoordPointerEXT', 'glVertexPointerEXT',
'PFNGLARRAYELEMENTEXTPROC', 'PFNGLCOLORPOINTEREXTPROC',
'PFNGLDRAWARRAYSEXTPROC', 'PFNGLEDGEFLAGPOINTEREXTPROC',
'PFNGLGETPOINTERVEXTPROC', 'PFNGLINDEXPOINTEREXTPROC',
'PFNGLNORMALPOINTEREXTPROC', 'PFNGLTEXCOORDPOINTEREXTPROC',
'PFNGLVERTEXPOINTEREXTPROC', 'GL_EXT_misc_attribute',
'GL_SGIS_generate_mipmap', 'GL_SGIX_clipmap', 'GL_SGIX_shadow',
'GL_SGIS_texture_edge_clamp', 'GL_SGIS_texture_border_clamp',
'GL_EXT_blend_minmax', 'glBlendEquationEXT', 'PFNGLBLENDEQUATIONEXTPROC',
'GL_EXT_blend_subtract', 'GL_EXT_blend_logic_op', 'GL_SGIX_interlace',
'GL_SGIX_pixel_tiles', 'GL_SGIX_texture_select', 'GL_SGIX_sprite',
'glSpriteParameterfSGIX', 'glSpriteParameterfvSGIX', 'glSpriteParameteriSGIX',
'glSpriteParameterivSGIX', 'PFNGLSPRITEPARAMETERFSGIXPROC',
'PFNGLSPRITEPARAMETERFVSGIXPROC', 'PFNGLSPRITEPARAMETERISGIXPROC',
'PFNGLSPRITEPARAMETERIVSGIXPROC', 'GL_SGIX_texture_multi_buffer',
'GL_EXT_point_parameters', 'glPointParameterfEXT', 'glPointParameterfvEXT',
'PFNGLPOINTPARAMETERFEXTPROC', 'PFNGLPOINTPARAMETERFVEXTPROC',
'GL_SGIS_point_parameters', 'glPointParameterfSGIS', 'glPointParameterfvSGIS',
'PFNGLPOINTPARAMETERFSGISPROC', 'PFNGLPOINTPARAMETERFVSGISPROC',
'GL_SGIX_instruments', 'glGetInstrumentsSGIX', 'glInstrumentsBufferSGIX',
'glPollInstrumentsSGIX', 'glReadInstrumentsSGIX', 'glStartInstrumentsSGIX',
'glStopInstrumentsSGIX', 'PFNGLGETINSTRUMENTSSGIXPROC',
'PFNGLINSTRUMENTSBUFFERSGIXPROC', 'PFNGLPOLLINSTRUMENTSSGIXPROC',
'PFNGLREADINSTRUMENTSSGIXPROC', 'PFNGLSTARTINSTRUMENTSSGIXPROC',
'PFNGLSTOPINSTRUMENTSSGIXPROC', 'GL_SGIX_texture_scale_bias',
'GL_SGIX_framezoom', 'glFrameZoomSGIX', 'PFNGLFRAMEZOOMSGIXPROC',
'GL_SGIX_tag_sample_buffer', 'glTagSampleBufferSGIX',
'PFNGLTAGSAMPLEBUFFERSGIXPROC', 'GL_SGIX_polynomial_ffd',
'glDeformationMap3dSGIX', 'glDeformationMap3fSGIX', 'glDeformSGIX',
'glLoadIdentityDeformationMapSGIX', 'PFNGLDEFORMATIONMAP3DSGIXPROC',
'PFNGLDEFORMATIONMAP3FSGIXPROC', 'PFNGLDEFORMSGIXPROC',
'PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC', 'GL_SGIX_reference_plane',
'glReferencePlaneSGIX', 'PFNGLREFERENCEPLANESGIXPROC', 'GL_SGIX_flush_raster',
'glFlushRasterSGIX', 'PFNGLFLUSHRASTERSGIXPROC', 'GL_SGIX_depth_texture',
'GL_SGIS_fog_function', 'glFogFuncSGIS', 'glGetFogFuncSGIS',
'PFNGLFOGFUNCSGISPROC', 'PFNGLGETFOGFUNCSGISPROC', 'GL_SGIX_fog_offset',
'GL_HP_image_transform', 'glImageTransformParameteriHP',
'glImageTransformParameterfHP', 'glImageTransformParameterivHP',
'glImageTransformParameterfvHP', 'glGetImageTransformParameterivHP',
'glGetImageTransformParameterfvHP', 'PFNGLIMAGETRANSFORMPARAMETERIHPPROC',
'PFNGLIMAGETRANSFORMPARAMETERFHPPROC', 'PFNGLIMAGETRANSFORMPARAMETERIVHPPROC',
'PFNGLIMAGETRANSFORMPARAMETERFVHPPROC',
'PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC',
'PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC', 'GL_HP_convolution_border_modes',
'GL_SGIX_texture_add_env', 'GL_EXT_color_subtable', 'glColorSubTableEXT',
'glCopyColorSubTableEXT', 'PFNGLCOLORSUBTABLEEXTPROC',
'PFNGLCOPYCOLORSUBTABLEEXTPROC', 'GL_PGI_vertex_hints', 'GL_PGI_misc_hints',
'glHintPGI', 'PFNGLHINTPGIPROC', 'GL_EXT_paletted_texture', 'glColorTableEXT',
'glGetColorTableEXT', 'glGetColorTableParameterivEXT',
'glGetColorTableParameterfvEXT', 'PFNGLCOLORTABLEEXTPROC',
'PFNGLGETCOLORTABLEEXTPROC', 'PFNGLGETCOLORTABLEPARAMETERIVEXTPROC',
'PFNGLGETCOLORTABLEPARAMETERFVEXTPROC', 'GL_EXT_clip_volume_hint',
'GL_SGIX_list_priority', 'glGetListParameterfvSGIX',
'glGetListParameterivSGIX', 'glListParameterfSGIX', 'glListParameterfvSGIX',
'glListParameteriSGIX', 'glListParameterivSGIX',
'PFNGLGETLISTPARAMETERFVSGIXPROC', 'PFNGLGETLISTPARAMETERIVSGIXPROC',
'PFNGLLISTPARAMETERFSGIXPROC', 'PFNGLLISTPARAMETERFVSGIXPROC',
'PFNGLLISTPARAMETERISGIXPROC', 'PFNGLLISTPARAMETERIVSGIXPROC',
'GL_SGIX_ir_instrument1', 'GL_SGIX_calligraphic_fragment',
'GL_SGIX_texture_lod_bias', 'GL_SGIX_shadow_ambient', 'GL_EXT_index_texture',
'GL_EXT_index_material', 'glIndexMaterialEXT', 'PFNGLINDEXMATERIALEXTPROC',
'GL_EXT_index_func', 'glIndexFuncEXT', 'PFNGLINDEXFUNCEXTPROC',
'GL_EXT_index_array_formats', 'GL_EXT_compiled_vertex_array',
'glLockArraysEXT', 'glUnlockArraysEXT', 'PFNGLLOCKARRAYSEXTPROC',
'PFNGLUNLOCKARRAYSEXTPROC', 'GL_EXT_cull_vertex', 'glCullParameterdvEXT',
'glCullParameterfvEXT', 'PFNGLCULLPARAMETERDVEXTPROC',
'PFNGLCULLPARAMETERFVEXTPROC', 'GL_SGIX_ycrcb', 'GL_SGIX_fragment_lighting',
'glFragmentColorMaterialSGIX', 'glFragmentLightfSGIX',
'glFragmentLightfvSGIX', 'glFragmentLightiSGIX', 'glFragmentLightivSGIX',
'glFragmentLightModelfSGIX', 'glFragmentLightModelfvSGIX',
'glFragmentLightModeliSGIX', 'glFragmentLightModelivSGIX',
'glFragmentMaterialfSGIX', 'glFragmentMaterialfvSGIX',
'glFragmentMaterialiSGIX', 'glFragmentMaterialivSGIX',
'glGetFragmentLightfvSGIX', 'glGetFragmentLightivSGIX',
'glGetFragmentMaterialfvSGIX', 'glGetFragmentMaterialivSGIX',
'glLightEnviSGIX', 'PFNGLFRAGMENTCOLORMATERIALSGIXPROC',
'PFNGLFRAGMENTLIGHTFSGIXPROC', 'PFNGLFRAGMENTLIGHTFVSGIXPROC',
'PFNGLFRAGMENTLIGHTISGIXPROC', 'PFNGLFRAGMENTLIGHTIVSGIXPROC',
'PFNGLFRAGMENTLIGHTMODELFSGIXPROC', 'PFNGLFRAGMENTLIGHTMODELFVSGIXPROC',
'PFNGLFRAGMENTLIGHTMODELISGIXPROC', 'PFNGLFRAGMENTLIGHTMODELIVSGIXPROC',
'PFNGLFRAGMENTMATERIALFSGIXPROC', 'PFNGLFRAGMENTMATERIALFVSGIXPROC',
'PFNGLFRAGMENTMATERIALISGIXPROC', 'PFNGLFRAGMENTMATERIALIVSGIXPROC',
'PFNGLGETFRAGMENTLIGHTFVSGIXPROC', 'PFNGLGETFRAGMENTLIGHTIVSGIXPROC',
'PFNGLGETFRAGMENTMATERIALFVSGIXPROC', 'PFNGLGETFRAGMENTMATERIALIVSGIXPROC',
'PFNGLLIGHTENVISGIXPROC', 'GL_IBM_rasterpos_clip', 'GL_HP_texture_lighting',
'GL_EXT_draw_range_elements', 'glDrawRangeElementsEXT',
'PFNGLDRAWRANGEELEMENTSEXTPROC', 'GL_WIN_phong_shading',
'GL_WIN_specular_fog', 'GL_EXT_light_texture', 'glApplyTextureEXT',
'glTextureLightEXT', 'glTextureMaterialEXT', 'PFNGLAPPLYTEXTUREEXTPROC',
'PFNGLTEXTURELIGHTEXTPROC', 'PFNGLTEXTUREMATERIALEXTPROC',
'GL_SGIX_blend_alpha_minmax', 'GL_EXT_bgra', 'GL_SGIX_async',
'glAsyncMarkerSGIX', 'glFinishAsyncSGIX', 'glPollAsyncSGIX',
'glGenAsyncMarkersSGIX', 'glDeleteAsyncMarkersSGIX', 'glIsAsyncMarkerSGIX',
'PFNGLASYNCMARKERSGIXPROC', 'PFNGLFINISHASYNCSGIXPROC',
'PFNGLPOLLASYNCSGIXPROC', 'PFNGLGENASYNCMARKERSSGIXPROC',
'PFNGLDELETEASYNCMARKERSSGIXPROC', 'PFNGLISASYNCMARKERSGIXPROC',
'GL_SGIX_async_pixel', 'GL_SGIX_async_histogram', 'GL_INTEL_parallel_arrays',
'glVertexPointervINTEL', 'glNormalPointervINTEL', 'glColorPointervINTEL',
'glTexCoordPointervINTEL', 'PFNGLVERTEXPOINTERVINTELPROC',
'PFNGLNORMALPOINTERVINTELPROC', 'PFNGLCOLORPOINTERVINTELPROC',
'PFNGLTEXCOORDPOINTERVINTELPROC', 'GL_HP_occlusion_test',
'GL_EXT_pixel_transform', 'glPixelTransformParameteriEXT',
'glPixelTransformParameterfEXT', 'glPixelTransformParameterivEXT',
'glPixelTransformParameterfvEXT', 'PFNGLPIXELTRANSFORMPARAMETERIEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERFEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC', 'GL_EXT_pixel_transform_color_table',
'GL_EXT_shared_texture_palette', 'GL_EXT_separate_specular_color',
'GL_EXT_secondary_color', 'glSecondaryColor3bEXT', 'glSecondaryColor3bvEXT',
'glSecondaryColor3dEXT', 'glSecondaryColor3dvEXT', 'glSecondaryColor3fEXT',
'glSecondaryColor3fvEXT', 'glSecondaryColor3iEXT', 'glSecondaryColor3ivEXT',
'glSecondaryColor3sEXT', 'glSecondaryColor3svEXT', 'glSecondaryColor3ubEXT',
'glSecondaryColor3ubvEXT', 'glSecondaryColor3uiEXT',
'glSecondaryColor3uivEXT', 'glSecondaryColor3usEXT',
'glSecondaryColor3usvEXT', 'glSecondaryColorPointerEXT',
'PFNGLSECONDARYCOLOR3BEXTPROC', 'PFNGLSECONDARYCOLOR3BVEXTPROC',
'PFNGLSECONDARYCOLOR3DEXTPROC', 'PFNGLSECONDARYCOLOR3DVEXTPROC',
'PFNGLSECONDARYCOLOR3FEXTPROC', 'PFNGLSECONDARYCOLOR3FVEXTPROC',
'PFNGLSECONDARYCOLOR3IEXTPROC', 'PFNGLSECONDARYCOLOR3IVEXTPROC',
'PFNGLSECONDARYCOLOR3SEXTPROC', 'PFNGLSECONDARYCOLOR3SVEXTPROC',
'PFNGLSECONDARYCOLOR3UBEXTPROC', 'PFNGLSECONDARYCOLOR3UBVEXTPROC',
'PFNGLSECONDARYCOLOR3UIEXTPROC', 'PFNGLSECONDARYCOLOR3UIVEXTPROC',
'PFNGLSECONDARYCOLOR3USEXTPROC', 'PFNGLSECONDARYCOLOR3USVEXTPROC',
'PFNGLSECONDARYCOLORPOINTEREXTPROC', 'GL_EXT_texture_perturb_normal',
'glTextureNormalEXT', 'PFNGLTEXTURENORMALEXTPROC', 'GL_EXT_multi_draw_arrays',
'glMultiDrawArraysEXT', 'glMultiDrawElementsEXT',
'PFNGLMULTIDRAWARRAYSEXTPROC', 'PFNGLMULTIDRAWELEMENTSEXTPROC',
'GL_EXT_fog_coord', 'glFogCoordfEXT', 'glFogCoordfvEXT', 'glFogCoorddEXT',
'glFogCoorddvEXT', 'glFogCoordPointerEXT', 'PFNGLFOGCOORDFEXTPROC',
'PFNGLFOGCOORDFVEXTPROC', 'PFNGLFOGCOORDDEXTPROC', 'PFNGLFOGCOORDDVEXTPROC',
'PFNGLFOGCOORDPOINTEREXTPROC', 'GL_REND_screen_coordinates',
'GL_EXT_coordinate_frame', 'glTangent3bEXT', 'glTangent3bvEXT',
'glTangent3dEXT', 'glTangent3dvEXT', 'glTangent3fEXT', 'glTangent3fvEXT',
'glTangent3iEXT', 'glTangent3ivEXT', 'glTangent3sEXT', 'glTangent3svEXT',
'glBinormal3bEXT', 'glBinormal3bvEXT', 'glBinormal3dEXT', 'glBinormal3dvEXT',
'glBinormal3fEXT', 'glBinormal3fvEXT', 'glBinormal3iEXT', 'glBinormal3ivEXT',
'glBinormal3sEXT', 'glBinormal3svEXT', 'glTangentPointerEXT',
'glBinormalPointerEXT', 'PFNGLTANGENT3BEXTPROC', 'PFNGLTANGENT3BVEXTPROC',
'PFNGLTANGENT3DEXTPROC', 'PFNGLTANGENT3DVEXTPROC', 'PFNGLTANGENT3FEXTPROC',
'PFNGLTANGENT3FVEXTPROC', 'PFNGLTANGENT3IEXTPROC', 'PFNGLTANGENT3IVEXTPROC',
'PFNGLTANGENT3SEXTPROC', 'PFNGLTANGENT3SVEXTPROC', 'PFNGLBINORMAL3BEXTPROC',
'PFNGLBINORMAL3BVEXTPROC', 'PFNGLBINORMAL3DEXTPROC',
'PFNGLBINORMAL3DVEXTPROC', 'PFNGLBINORMAL3FEXTPROC',
'PFNGLBINORMAL3FVEXTPROC', 'PFNGLBINORMAL3IEXTPROC',
'PFNGLBINORMAL3IVEXTPROC', 'PFNGLBINORMAL3SEXTPROC',
'PFNGLBINORMAL3SVEXTPROC', 'PFNGLTANGENTPOINTEREXTPROC',
'PFNGLBINORMALPOINTEREXTPROC', 'GL_EXT_texture_env_combine',
'GL_APPLE_specular_vector', 'GL_APPLE_transform_hint', 'GL_SGIX_fog_scale',
'GL_SUNX_constant_data', 'glFinishTextureSUNX', 'PFNGLFINISHTEXTURESUNXPROC',
'GL_SUN_global_alpha', 'glGlobalAlphaFactorbSUN', 'glGlobalAlphaFactorsSUN',
'glGlobalAlphaFactoriSUN', 'glGlobalAlphaFactorfSUN',
'glGlobalAlphaFactordSUN', 'glGlobalAlphaFactorubSUN',
'glGlobalAlphaFactorusSUN', 'glGlobalAlphaFactoruiSUN',
'PFNGLGLOBALALPHAFACTORBSUNPROC', 'PFNGLGLOBALALPHAFACTORSSUNPROC',
'PFNGLGLOBALALPHAFACTORISUNPROC', 'PFNGLGLOBALALPHAFACTORFSUNPROC',
'PFNGLGLOBALALPHAFACTORDSUNPROC', 'PFNGLGLOBALALPHAFACTORUBSUNPROC',
'PFNGLGLOBALALPHAFACTORUSSUNPROC', 'PFNGLGLOBALALPHAFACTORUISUNPROC',
'GL_SUN_triangle_list', 'glReplacementCodeuiSUN', 'glReplacementCodeusSUN',
'glReplacementCodeubSUN', 'glReplacementCodeuivSUN',
'glReplacementCodeusvSUN', 'glReplacementCodeubvSUN',
'glReplacementCodePointerSUN', 'PFNGLREPLACEMENTCODEUISUNPROC',
'PFNGLREPLACEMENTCODEUSSUNPROC', 'PFNGLREPLACEMENTCODEUBSUNPROC',
'PFNGLREPLACEMENTCODEUIVSUNPROC', 'PFNGLREPLACEMENTCODEUSVSUNPROC',
'PFNGLREPLACEMENTCODEUBVSUNPROC', 'PFNGLREPLACEMENTCODEPOINTERSUNPROC',
'GL_SUN_vertex', 'glColor4ubVertex2fSUN', 'glColor4ubVertex2fvSUN',
'glColor4ubVertex3fSUN', 'glColor4ubVertex3fvSUN', 'glColor3fVertex3fSUN',
'glColor3fVertex3fvSUN', 'glNormal3fVertex3fSUN', 'glNormal3fVertex3fvSUN',
'glColor4fNormal3fVertex3fSUN', 'glColor4fNormal3fVertex3fvSUN',
'glTexCoord2fVertex3fSUN', 'glTexCoord2fVertex3fvSUN',
'glTexCoord4fVertex4fSUN', 'glTexCoord4fVertex4fvSUN',
'glTexCoord2fColor4ubVertex3fSUN', 'glTexCoord2fColor4ubVertex3fvSUN',
'glTexCoord2fColor3fVertex3fSUN', 'glTexCoord2fColor3fVertex3fvSUN',
'glTexCoord2fNormal3fVertex3fSUN', 'glTexCoord2fNormal3fVertex3fvSUN',
'glTexCoord2fColor4fNormal3fVertex3fSUN',
'glTexCoord2fColor4fNormal3fVertex3fvSUN',
'glTexCoord4fColor4fNormal3fVertex4fSUN',
'glTexCoord4fColor4fNormal3fVertex4fvSUN', 'glReplacementCodeuiVertex3fSUN',
'glReplacementCodeuiVertex3fvSUN', 'glReplacementCodeuiColor4ubVertex3fSUN',
'glReplacementCodeuiColor4ubVertex3fvSUN',
'glReplacementCodeuiColor3fVertex3fSUN',
'glReplacementCodeuiColor3fVertex3fvSUN',
'glReplacementCodeuiNormal3fVertex3fSUN',
'glReplacementCodeuiNormal3fVertex3fvSUN',
'glReplacementCodeuiColor4fNormal3fVertex3fSUN',
'glReplacementCodeuiColor4fNormal3fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fVertex3fSUN',
'glReplacementCodeuiTexCoord2fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN',
'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN',
'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN',
'PFNGLCOLOR4UBVERTEX2FSUNPROC', 'PFNGLCOLOR4UBVERTEX2FVSUNPROC',
'PFNGLCOLOR4UBVERTEX3FSUNPROC', 'PFNGLCOLOR4UBVERTEX3FVSUNPROC',
'PFNGLCOLOR3FVERTEX3FSUNPROC', 'PFNGLCOLOR3FVERTEX3FVSUNPROC',
'PFNGLNORMAL3FVERTEX3FSUNPROC', 'PFNGLNORMAL3FVERTEX3FVSUNPROC',
'PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC', 'PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FVERTEX3FSUNPROC', 'PFNGLTEXCOORD2FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD4FVERTEX4FSUNPROC', 'PFNGLTEXCOORD4FVERTEX4FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC',
'PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC',
'PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'GL_EXT_blend_func_separate', 'glBlendFuncSeparateEXT',
'PFNGLBLENDFUNCSEPARATEEXTPROC', 'GL_INGR_blend_func_separate',
'glBlendFuncSeparateINGR', 'PFNGLBLENDFUNCSEPARATEINGRPROC',
'GL_INGR_color_clamp', 'GL_INGR_interlace_read', 'GL_EXT_stencil_wrap',
'GL_EXT_422_pixels', 'GL_NV_texgen_reflection',
'GL_SUN_convolution_border_modes', 'GL_EXT_texture_env_add',
'GL_EXT_texture_lod_bias', 'GL_EXT_texture_filter_anisotropic',
'GL_EXT_vertex_weighting', 'glVertexWeightfEXT', 'glVertexWeightfvEXT',
'glVertexWeightPointerEXT', 'PFNGLVERTEXWEIGHTFEXTPROC',
'PFNGLVERTEXWEIGHTFVEXTPROC', 'PFNGLVERTEXWEIGHTPOINTEREXTPROC',
'GL_NV_light_max_exponent', 'GL_NV_vertex_array_range',
'glFlushVertexArrayRangeNV', 'glVertexArrayRangeNV',
'PFNGLFLUSHVERTEXARRAYRANGENVPROC', 'PFNGLVERTEXARRAYRANGENVPROC',
'GL_NV_register_combiners', 'glCombinerParameterfvNV',
'glCombinerParameterfNV', 'glCombinerParameterivNV', 'glCombinerParameteriNV',
'glCombinerInputNV', 'glCombinerOutputNV', 'glFinalCombinerInputNV',
'glGetCombinerInputParameterfvNV', 'glGetCombinerInputParameterivNV',
'glGetCombinerOutputParameterfvNV', 'glGetCombinerOutputParameterivNV',
'glGetFinalCombinerInputParameterfvNV',
'glGetFinalCombinerInputParameterivNV', 'PFNGLCOMBINERPARAMETERFVNVPROC',
'PFNGLCOMBINERPARAMETERFNVPROC', 'PFNGLCOMBINERPARAMETERIVNVPROC',
'PFNGLCOMBINERPARAMETERINVPROC', 'PFNGLCOMBINERINPUTNVPROC',
'PFNGLCOMBINEROUTPUTNVPROC', 'PFNGLFINALCOMBINERINPUTNVPROC',
'PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC',
'PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC',
'PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC',
'PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC',
'PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC',
'PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC', 'GL_NV_fog_distance',
'GL_NV_texgen_emboss', 'GL_NV_blend_square', 'GL_NV_texture_env_combine4',
'GL_MESA_resize_buffers', 'glResizeBuffersMESA', 'PFNGLRESIZEBUFFERSMESAPROC',
'GL_MESA_window_pos', 'glWindowPos2dMESA', 'glWindowPos2dvMESA',
'glWindowPos2fMESA', 'glWindowPos2fvMESA', 'glWindowPos2iMESA',
'glWindowPos2ivMESA', 'glWindowPos2sMESA', 'glWindowPos2svMESA',
'glWindowPos3dMESA', 'glWindowPos3dvMESA', 'glWindowPos3fMESA',
'glWindowPos3fvMESA', 'glWindowPos3iMESA', 'glWindowPos3ivMESA',
'glWindowPos3sMESA', 'glWindowPos3svMESA', 'glWindowPos4dMESA',
'glWindowPos4dvMESA', 'glWindowPos4fMESA', 'glWindowPos4fvMESA',
'glWindowPos4iMESA', 'glWindowPos4ivMESA', 'glWindowPos4sMESA',
'glWindowPos4svMESA', 'PFNGLWINDOWPOS2DMESAPROC', 'PFNGLWINDOWPOS2DVMESAPROC',
'PFNGLWINDOWPOS2FMESAPROC', 'PFNGLWINDOWPOS2FVMESAPROC',
'PFNGLWINDOWPOS2IMESAPROC', 'PFNGLWINDOWPOS2IVMESAPROC',
'PFNGLWINDOWPOS2SMESAPROC', 'PFNGLWINDOWPOS2SVMESAPROC',
'PFNGLWINDOWPOS3DMESAPROC', 'PFNGLWINDOWPOS3DVMESAPROC',
'PFNGLWINDOWPOS3FMESAPROC', 'PFNGLWINDOWPOS3FVMESAPROC',
'PFNGLWINDOWPOS3IMESAPROC', 'PFNGLWINDOWPOS3IVMESAPROC',
'PFNGLWINDOWPOS3SMESAPROC', 'PFNGLWINDOWPOS3SVMESAPROC',
'PFNGLWINDOWPOS4DMESAPROC', 'PFNGLWINDOWPOS4DVMESAPROC',
'PFNGLWINDOWPOS4FMESAPROC', 'PFNGLWINDOWPOS4FVMESAPROC',
'PFNGLWINDOWPOS4IMESAPROC', 'PFNGLWINDOWPOS4IVMESAPROC',
'PFNGLWINDOWPOS4SMESAPROC', 'PFNGLWINDOWPOS4SVMESAPROC',
'GL_EXT_texture_compression_s3tc', 'GL_IBM_cull_vertex',
'GL_IBM_multimode_draw_arrays', 'glMultiModeDrawArraysIBM',
'glMultiModeDrawElementsIBM', 'PFNGLMULTIMODEDRAWARRAYSIBMPROC',
'PFNGLMULTIMODEDRAWELEMENTSIBMPROC', 'GL_IBM_vertex_array_lists',
'glColorPointerListIBM', 'glSecondaryColorPointerListIBM',
'glEdgeFlagPointerListIBM', 'glFogCoordPointerListIBM',
'glIndexPointerListIBM', 'glNormalPointerListIBM', 'glTexCoordPointerListIBM',
'glVertexPointerListIBM', 'PFNGLCOLORPOINTERLISTIBMPROC',
'PFNGLSECONDARYCOLORPOINTERLISTIBMPROC', 'PFNGLEDGEFLAGPOINTERLISTIBMPROC',
'PFNGLFOGCOORDPOINTERLISTIBMPROC', 'PFNGLINDEXPOINTERLISTIBMPROC',
'PFNGLNORMALPOINTERLISTIBMPROC', 'PFNGLTEXCOORDPOINTERLISTIBMPROC',
'PFNGLVERTEXPOINTERLISTIBMPROC', 'GL_SGIX_subsample', 'GL_SGIX_ycrcba',
'GL_SGIX_ycrcb_subsample', 'GL_SGIX_depth_pass_instrument',
'GL_3DFX_texture_compression_FXT1', 'GL_3DFX_multisample', 'GL_3DFX_tbuffer',
'glTbufferMask3DFX', 'PFNGLTBUFFERMASK3DFXPROC', 'GL_EXT_multisample',
'glSampleMaskEXT', 'glSamplePatternEXT', 'PFNGLSAMPLEMASKEXTPROC',
'PFNGLSAMPLEPATTERNEXTPROC', 'GL_SGIX_vertex_preclip',
'GL_SGIX_convolution_accuracy', 'GL_SGIX_resample',
'GL_SGIS_point_line_texgen', 'GL_SGIS_texture_color_mask',
'glTextureColorMaskSGIS', 'PFNGLTEXTURECOLORMASKSGISPROC',
'GL_SGIX_igloo_interface', 'glIglooInterfaceSGIX',
'PFNGLIGLOOINTERFACESGIXPROC', 'GL_EXT_texture_env_dot3',
'GL_ATI_texture_mirror_once', 'GL_NV_fence', 'glDeleteFencesNV',
'glGenFencesNV', 'glIsFenceNV', 'glTestFenceNV', 'glGetFenceivNV',
'glFinishFenceNV', 'glSetFenceNV', 'PFNGLDELETEFENCESNVPROC',
'PFNGLGENFENCESNVPROC', 'PFNGLISFENCENVPROC', 'PFNGLTESTFENCENVPROC',
'PFNGLGETFENCEIVNVPROC', 'PFNGLFINISHFENCENVPROC', 'PFNGLSETFENCENVPROC',
'GL_NV_evaluators', 'glMapControlPointsNV', 'glMapParameterivNV',
'glMapParameterfvNV', 'glGetMapControlPointsNV', 'glGetMapParameterivNV',
'glGetMapParameterfvNV', 'glGetMapAttribParameterivNV',
'glGetMapAttribParameterfvNV', 'glEvalMapsNV', 'PFNGLMAPCONTROLPOINTSNVPROC',
'PFNGLMAPPARAMETERIVNVPROC', 'PFNGLMAPPARAMETERFVNVPROC',
'PFNGLGETMAPCONTROLPOINTSNVPROC', 'PFNGLGETMAPPARAMETERIVNVPROC',
'PFNGLGETMAPPARAMETERFVNVPROC', 'PFNGLGETMAPATTRIBPARAMETERIVNVPROC',
'PFNGLGETMAPATTRIBPARAMETERFVNVPROC', 'PFNGLEVALMAPSNVPROC',
'GL_NV_packed_depth_stencil', 'GL_EXT_packed_depth_stencil',
'GL_NV_register_combiners2', 'glCombinerStageParameterfvNV',
'glGetCombinerStageParameterfvNV', 'PFNGLCOMBINERSTAGEPARAMETERFVNVPROC',
'PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC', 'GL_NV_texture_compression_vtc',
'GL_NV_texture_rectangle', 'GL_NV_texture_shader', 'GL_NV_texture_shader2',
'GL_NV_vertex_array_range2', 'GL_NV_vertex_program',
'glAreProgramsResidentNV', 'glBindProgramNV', 'glDeleteProgramsNV',
'glExecuteProgramNV', 'glGenProgramsNV', 'glGetProgramParameterdvNV',
'glGetProgramParameterfvNV', 'glGetProgramivNV', 'glGetProgramStringNV',
'glGetTrackMatrixivNV', 'glGetVertexAttribdvNV', 'glGetVertexAttribfvNV',
'glGetVertexAttribivNV', 'glGetVertexAttribPointervNV', 'glIsProgramNV',
'glLoadProgramNV', 'glProgramParameter4dNV', 'glProgramParameter4dvNV',
'glProgramParameter4fNV', 'glProgramParameter4fvNV',
'glProgramParameters4dvNV', 'glProgramParameters4fvNV',
'glRequestResidentProgramsNV', 'glTrackMatrixNV', 'glVertexAttribPointerNV',
'glVertexAttrib1dNV', 'glVertexAttrib1dvNV', 'glVertexAttrib1fNV',
'glVertexAttrib1fvNV', 'glVertexAttrib1sNV', 'glVertexAttrib1svNV',
'glVertexAttrib2dNV', 'glVertexAttrib2dvNV', 'glVertexAttrib2fNV',
'glVertexAttrib2fvNV', 'glVertexAttrib2sNV', 'glVertexAttrib2svNV',
'glVertexAttrib3dNV', 'glVertexAttrib3dvNV', 'glVertexAttrib3fNV',
'glVertexAttrib3fvNV', 'glVertexAttrib3sNV', 'glVertexAttrib3svNV',
'glVertexAttrib4dNV', 'glVertexAttrib4dvNV', 'glVertexAttrib4fNV',
'glVertexAttrib4fvNV', 'glVertexAttrib4sNV', 'glVertexAttrib4svNV',
'glVertexAttrib4ubNV', 'glVertexAttrib4ubvNV', 'glVertexAttribs1dvNV',
'glVertexAttribs1fvNV', 'glVertexAttribs1svNV', 'glVertexAttribs2dvNV',
'glVertexAttribs2fvNV', 'glVertexAttribs2svNV', 'glVertexAttribs3dvNV',
'glVertexAttribs3fvNV', 'glVertexAttribs3svNV', 'glVertexAttribs4dvNV',
'glVertexAttribs4fvNV', 'glVertexAttribs4svNV', 'glVertexAttribs4ubvNV',
'PFNGLAREPROGRAMSRESIDENTNVPROC', 'PFNGLBINDPROGRAMNVPROC',
'PFNGLDELETEPROGRAMSNVPROC', 'PFNGLEXECUTEPROGRAMNVPROC',
'PFNGLGENPROGRAMSNVPROC', 'PFNGLGETPROGRAMPARAMETERDVNVPROC',
'PFNGLGETPROGRAMPARAMETERFVNVPROC', 'PFNGLGETPROGRAMIVNVPROC',
'PFNGLGETPROGRAMSTRINGNVPROC', 'PFNGLGETTRACKMATRIXIVNVPROC',
'PFNGLGETVERTEXATTRIBDVNVPROC', 'PFNGLGETVERTEXATTRIBFVNVPROC',
'PFNGLGETVERTEXATTRIBIVNVPROC', 'PFNGLGETVERTEXATTRIBPOINTERVNVPROC',
'PFNGLISPROGRAMNVPROC', 'PFNGLLOADPROGRAMNVPROC',
'PFNGLPROGRAMPARAMETER4DNVPROC', 'PFNGLPROGRAMPARAMETER4DVNVPROC',
'PFNGLPROGRAMPARAMETER4FNVPROC', 'PFNGLPROGRAMPARAMETER4FVNVPROC',
'PFNGLPROGRAMPARAMETERS4DVNVPROC', 'PFNGLPROGRAMPARAMETERS4FVNVPROC',
'PFNGLREQUESTRESIDENTPROGRAMSNVPROC', 'PFNGLTRACKMATRIXNVPROC',
'PFNGLVERTEXATTRIBPOINTERNVPROC', 'PFNGLVERTEXATTRIB1DNVPROC',
'PFNGLVERTEXATTRIB1DVNVPROC', 'PFNGLVERTEXATTRIB1FNVPROC',
'PFNGLVERTEXATTRIB1FVNVPROC', 'PFNGLVERTEXATTRIB1SNVPROC',
'PFNGLVERTEXATTRIB1SVNVPROC', 'PFNGLVERTEXATTRIB2DNVPROC',
'PFNGLVERTEXATTRIB2DVNVPROC', 'PFNGLVERTEXATTRIB2FNVPROC',
'PFNGLVERTEXATTRIB2FVNVPROC', 'PFNGLVERTEXATTRIB2SNVPROC',
'PFNGLVERTEXATTRIB2SVNVPROC', 'PFNGLVERTEXATTRIB3DNVPROC',
'PFNGLVERTEXATTRIB3DVNVPROC', 'PFNGLVERTEXATTRIB3FNVPROC',
'PFNGLVERTEXATTRIB3FVNVPROC', 'PFNGLVERTEXATTRIB3SNVPROC',
'PFNGLVERTEXATTRIB3SVNVPROC', 'PFNGLVERTEXATTRIB4DNVPROC',
'PFNGLVERTEXATTRIB4DVNVPROC', 'PFNGLVERTEXATTRIB4FNVPROC',
'PFNGLVERTEXATTRIB4FVNVPROC', 'PFNGLVERTEXATTRIB4SNVPROC',
'PFNGLVERTEXATTRIB4SVNVPROC', 'PFNGLVERTEXATTRIB4UBNVPROC',
'PFNGLVERTEXATTRIB4UBVNVPROC', 'PFNGLVERTEXATTRIBS1DVNVPROC',
'PFNGLVERTEXATTRIBS1FVNVPROC', 'PFNGLVERTEXATTRIBS1SVNVPROC',
'PFNGLVERTEXATTRIBS2DVNVPROC', 'PFNGLVERTEXATTRIBS2FVNVPROC',
'PFNGLVERTEXATTRIBS2SVNVPROC', 'PFNGLVERTEXATTRIBS3DVNVPROC',
'PFNGLVERTEXATTRIBS3FVNVPROC', 'PFNGLVERTEXATTRIBS3SVNVPROC',
'PFNGLVERTEXATTRIBS4DVNVPROC', 'PFNGLVERTEXATTRIBS4FVNVPROC',
'PFNGLVERTEXATTRIBS4SVNVPROC', 'PFNGLVERTEXATTRIBS4UBVNVPROC',
'GL_SGIX_texture_coordinate_clamp', 'GL_SGIX_scalebias_hint',
'GL_OML_interlace', 'GL_OML_subsample', 'GL_OML_resample',
'GL_NV_copy_depth_to_color', 'GL_ATI_envmap_bumpmap',
'glTexBumpParameterivATI', 'glTexBumpParameterfvATI',
'glGetTexBumpParameterivATI', 'glGetTexBumpParameterfvATI',
'PFNGLTEXBUMPPARAMETERIVATIPROC', 'PFNGLTEXBUMPPARAMETERFVATIPROC',
'PFNGLGETTEXBUMPPARAMETERIVATIPROC', 'PFNGLGETTEXBUMPPARAMETERFVATIPROC',
'GL_ATI_fragment_shader', 'glGenFragmentShadersATI',
'glBindFragmentShaderATI', 'glDeleteFragmentShaderATI',
'glBeginFragmentShaderATI', 'glEndFragmentShaderATI', 'glPassTexCoordATI',
'glSampleMapATI', 'glColorFragmentOp1ATI', 'glColorFragmentOp2ATI',
'glColorFragmentOp3ATI', 'glAlphaFragmentOp1ATI', 'glAlphaFragmentOp2ATI',
'glAlphaFragmentOp3ATI', 'glSetFragmentShaderConstantATI',
'PFNGLGENFRAGMENTSHADERSATIPROC', 'PFNGLBINDFRAGMENTSHADERATIPROC',
'PFNGLDELETEFRAGMENTSHADERATIPROC', 'PFNGLBEGINFRAGMENTSHADERATIPROC',
'PFNGLENDFRAGMENTSHADERATIPROC', 'PFNGLPASSTEXCOORDATIPROC',
'PFNGLSAMPLEMAPATIPROC', 'PFNGLCOLORFRAGMENTOP1ATIPROC',
'PFNGLCOLORFRAGMENTOP2ATIPROC', 'PFNGLCOLORFRAGMENTOP3ATIPROC',
'PFNGLALPHAFRAGMENTOP1ATIPROC', 'PFNGLALPHAFRAGMENTOP2ATIPROC',
'PFNGLALPHAFRAGMENTOP3ATIPROC', 'PFNGLSETFRAGMENTSHADERCONSTANTATIPROC',
'GL_ATI_pn_triangles', 'glPNTrianglesiATI', 'glPNTrianglesfATI',
'PFNGLPNTRIANGLESIATIPROC', 'PFNGLPNTRIANGLESFATIPROC',
'GL_ATI_vertex_array_object', 'glNewObjectBufferATI', 'glIsObjectBufferATI',
'glUpdateObjectBufferATI', 'glGetObjectBufferfvATI', 'glGetObjectBufferivATI',
'glFreeObjectBufferATI', 'glArrayObjectATI', 'glGetArrayObjectfvATI',
'glGetArrayObjectivATI', 'glVariantArrayObjectATI',
'glGetVariantArrayObjectfvATI', 'glGetVariantArrayObjectivATI',
'PFNGLNEWOBJECTBUFFERATIPROC', 'PFNGLISOBJECTBUFFERATIPROC',
'PFNGLUPDATEOBJECTBUFFERATIPROC', 'PFNGLGETOBJECTBUFFERFVATIPROC',
'PFNGLGETOBJECTBUFFERIVATIPROC', 'PFNGLFREEOBJECTBUFFERATIPROC',
'PFNGLARRAYOBJECTATIPROC', 'PFNGLGETARRAYOBJECTFVATIPROC',
'PFNGLGETARRAYOBJECTIVATIPROC', 'PFNGLVARIANTARRAYOBJECTATIPROC',
'PFNGLGETVARIANTARRAYOBJECTFVATIPROC', 'PFNGLGETVARIANTARRAYOBJECTIVATIPROC',
'GL_EXT_vertex_shader', 'glBeginVertexShaderEXT', 'glEndVertexShaderEXT',
'glBindVertexShaderEXT', 'glGenVertexShadersEXT', 'glDeleteVertexShaderEXT',
'glShaderOp1EXT', 'glShaderOp2EXT', 'glShaderOp3EXT', 'glSwizzleEXT',
'glWriteMaskEXT', 'glInsertComponentEXT', 'glExtractComponentEXT',
'glGenSymbolsEXT', 'glSetInvariantEXT', 'glSetLocalConstantEXT',
'glVariantbvEXT', 'glVariantsvEXT', 'glVariantivEXT', 'glVariantfvEXT',
'glVariantdvEXT', 'glVariantubvEXT', 'glVariantusvEXT', 'glVariantuivEXT',
'glVariantPointerEXT', 'glEnableVariantClientStateEXT',
'glDisableVariantClientStateEXT', 'glBindLightParameterEXT',
'glBindMaterialParameterEXT', 'glBindTexGenParameterEXT',
'glBindTextureUnitParameterEXT', 'glBindParameterEXT',
'glIsVariantEnabledEXT', 'glGetVariantBooleanvEXT', 'glGetVariantIntegervEXT',
'glGetVariantFloatvEXT', 'glGetVariantPointervEXT',
'glGetInvariantBooleanvEXT', 'glGetInvariantIntegervEXT',
'glGetInvariantFloatvEXT', 'glGetLocalConstantBooleanvEXT',
'glGetLocalConstantIntegervEXT', 'glGetLocalConstantFloatvEXT',
'PFNGLBEGINVERTEXSHADEREXTPROC', 'PFNGLENDVERTEXSHADEREXTPROC',
'PFNGLBINDVERTEXSHADEREXTPROC', 'PFNGLGENVERTEXSHADERSEXTPROC',
'PFNGLDELETEVERTEXSHADEREXTPROC', 'PFNGLSHADEROP1EXTPROC',
'PFNGLSHADEROP2EXTPROC', 'PFNGLSHADEROP3EXTPROC', 'PFNGLSWIZZLEEXTPROC',
'PFNGLWRITEMASKEXTPROC', 'PFNGLINSERTCOMPONENTEXTPROC',
'PFNGLEXTRACTCOMPONENTEXTPROC', 'PFNGLGENSYMBOLSEXTPROC',
'PFNGLSETINVARIANTEXTPROC', 'PFNGLSETLOCALCONSTANTEXTPROC',
'PFNGLVARIANTBVEXTPROC', 'PFNGLVARIANTSVEXTPROC', 'PFNGLVARIANTIVEXTPROC',
'PFNGLVARIANTFVEXTPROC', 'PFNGLVARIANTDVEXTPROC', 'PFNGLVARIANTUBVEXTPROC',
'PFNGLVARIANTUSVEXTPROC', 'PFNGLVARIANTUIVEXTPROC',
'PFNGLVARIANTPOINTEREXTPROC', 'PFNGLENABLEVARIANTCLIENTSTATEEXTPROC',
'PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC', 'PFNGLBINDLIGHTPARAMETEREXTPROC',
'PFNGLBINDMATERIALPARAMETEREXTPROC', 'PFNGLBINDTEXGENPARAMETEREXTPROC',
'PFNGLBINDTEXTUREUNITPARAMETEREXTPROC', 'PFNGLBINDPARAMETEREXTPROC',
'PFNGLISVARIANTENABLEDEXTPROC', 'PFNGLGETVARIANTBOOLEANVEXTPROC',
'PFNGLGETVARIANTINTEGERVEXTPROC', 'PFNGLGETVARIANTFLOATVEXTPROC',
'PFNGLGETVARIANTPOINTERVEXTPROC', 'PFNGLGETINVARIANTBOOLEANVEXTPROC',
'PFNGLGETINVARIANTINTEGERVEXTPROC', 'PFNGLGETINVARIANTFLOATVEXTPROC',
'PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC',
'PFNGLGETLOCALCONSTANTINTEGERVEXTPROC', 'PFNGLGETLOCALCONSTANTFLOATVEXTPROC',
'GL_ATI_vertex_streams', 'glVertexStream1sATI', 'glVertexStream1svATI',
'glVertexStream1iATI', 'glVertexStream1ivATI', 'glVertexStream1fATI',
'glVertexStream1fvATI', 'glVertexStream1dATI', 'glVertexStream1dvATI',
'glVertexStream2sATI', 'glVertexStream2svATI', 'glVertexStream2iATI',
'glVertexStream2ivATI', 'glVertexStream2fATI', 'glVertexStream2fvATI',
'glVertexStream2dATI', 'glVertexStream2dvATI', 'glVertexStream3sATI',
'glVertexStream3svATI', 'glVertexStream3iATI', 'glVertexStream3ivATI',
'glVertexStream3fATI', 'glVertexStream3fvATI', 'glVertexStream3dATI',
'glVertexStream3dvATI', 'glVertexStream4sATI', 'glVertexStream4svATI',
'glVertexStream4iATI', 'glVertexStream4ivATI', 'glVertexStream4fATI',
'glVertexStream4fvATI', 'glVertexStream4dATI', 'glVertexStream4dvATI',
'glNormalStream3bATI', 'glNormalStream3bvATI', 'glNormalStream3sATI',
'glNormalStream3svATI', 'glNormalStream3iATI', 'glNormalStream3ivATI',
'glNormalStream3fATI', 'glNormalStream3fvATI', 'glNormalStream3dATI',
'glNormalStream3dvATI', 'glClientActiveVertexStreamATI',
'glVertexBlendEnviATI', 'glVertexBlendEnvfATI', 'PFNGLVERTEXSTREAM1SATIPROC',
'PFNGLVERTEXSTREAM1SVATIPROC', 'PFNGLVERTEXSTREAM1IATIPROC',
'PFNGLVERTEXSTREAM1IVATIPROC', 'PFNGLVERTEXSTREAM1FATIPROC',
'PFNGLVERTEXSTREAM1FVATIPROC', 'PFNGLVERTEXSTREAM1DATIPROC',
'PFNGLVERTEXSTREAM1DVATIPROC', 'PFNGLVERTEXSTREAM2SATIPROC',
'PFNGLVERTEXSTREAM2SVATIPROC', 'PFNGLVERTEXSTREAM2IATIPROC',
'PFNGLVERTEXSTREAM2IVATIPROC', 'PFNGLVERTEXSTREAM2FATIPROC',
'PFNGLVERTEXSTREAM2FVATIPROC', 'PFNGLVERTEXSTREAM2DATIPROC',
'PFNGLVERTEXSTREAM2DVATIPROC', 'PFNGLVERTEXSTREAM3SATIPROC',
'PFNGLVERTEXSTREAM3SVATIPROC', 'PFNGLVERTEXSTREAM3IATIPROC',
'PFNGLVERTEXSTREAM3IVATIPROC', 'PFNGLVERTEXSTREAM3FATIPROC',
'PFNGLVERTEXSTREAM3FVATIPROC', 'PFNGLVERTEXSTREAM3DATIPROC',
'PFNGLVERTEXSTREAM3DVATIPROC', 'PFNGLVERTEXSTREAM4SATIPROC',
'PFNGLVERTEXSTREAM4SVATIPROC', 'PFNGLVERTEXSTREAM4IATIPROC',
'PFNGLVERTEXSTREAM4IVATIPROC', 'PFNGLVERTEXSTREAM4FATIPROC',
'PFNGLVERTEXSTREAM4FVATIPROC', 'PFNGLVERTEXSTREAM4DATIPROC',
'PFNGLVERTEXSTREAM4DVATIPROC', 'PFNGLNORMALSTREAM3BATIPROC',
'PFNGLNORMALSTREAM3BVATIPROC', 'PFNGLNORMALSTREAM3SATIPROC',
'PFNGLNORMALSTREAM3SVATIPROC', 'PFNGLNORMALSTREAM3IATIPROC',
'PFNGLNORMALSTREAM3IVATIPROC', 'PFNGLNORMALSTREAM3FATIPROC',
'PFNGLNORMALSTREAM3FVATIPROC', 'PFNGLNORMALSTREAM3DATIPROC',
'PFNGLNORMALSTREAM3DVATIPROC', 'PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC',
'PFNGLVERTEXBLENDENVIATIPROC', 'PFNGLVERTEXBLENDENVFATIPROC',
'GL_ATI_element_array', 'glElementPointerATI', 'glDrawElementArrayATI',
'glDrawRangeElementArrayATI', 'PFNGLELEMENTPOINTERATIPROC',
'PFNGLDRAWELEMENTARRAYATIPROC', 'PFNGLDRAWRANGEELEMENTARRAYATIPROC',
'GL_SUN_mesh_array', 'glDrawMeshArraysSUN', 'PFNGLDRAWMESHARRAYSSUNPROC',
'GL_SUN_slice_accum', 'GL_NV_multisample_filter_hint', 'GL_NV_depth_clamp',
'GL_NV_occlusion_query', 'glGenOcclusionQueriesNV',
'glDeleteOcclusionQueriesNV', 'glIsOcclusionQueryNV',
'glBeginOcclusionQueryNV', 'glEndOcclusionQueryNV', 'glGetOcclusionQueryivNV',
'glGetOcclusionQueryuivNV', 'PFNGLGENOCCLUSIONQUERIESNVPROC',
'PFNGLDELETEOCCLUSIONQUERIESNVPROC', 'PFNGLISOCCLUSIONQUERYNVPROC',
'PFNGLBEGINOCCLUSIONQUERYNVPROC', 'PFNGLENDOCCLUSIONQUERYNVPROC',
'PFNGLGETOCCLUSIONQUERYIVNVPROC', 'PFNGLGETOCCLUSIONQUERYUIVNVPROC',
'GL_NV_point_sprite', 'glPointParameteriNV', 'glPointParameterivNV',
'PFNGLPOINTPARAMETERINVPROC', 'PFNGLPOINTPARAMETERIVNVPROC',
'GL_NV_texture_shader3', 'GL_NV_vertex_program1_1', 'GL_EXT_shadow_funcs',
'GL_EXT_stencil_two_side', 'glActiveStencilFaceEXT',
'PFNGLACTIVESTENCILFACEEXTPROC', 'GL_ATI_text_fragment_shader',
'GL_APPLE_client_storage', 'GL_APPLE_element_array', 'glElementPointerAPPLE',
'glDrawElementArrayAPPLE', 'glDrawRangeElementArrayAPPLE',
'glMultiDrawElementArrayAPPLE', 'glMultiDrawRangeElementArrayAPPLE',
'PFNGLELEMENTPOINTERAPPLEPROC', 'PFNGLDRAWELEMENTARRAYAPPLEPROC',
'PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC', 'PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC',
'PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC', 'GL_APPLE_fence',
'glGenFencesAPPLE', 'glDeleteFencesAPPLE', 'glSetFenceAPPLE',
'glIsFenceAPPLE', 'glTestFenceAPPLE', 'glFinishFenceAPPLE',
'glTestObjectAPPLE', 'glFinishObjectAPPLE', 'PFNGLGENFENCESAPPLEPROC',
'PFNGLDELETEFENCESAPPLEPROC', 'PFNGLSETFENCEAPPLEPROC',
'PFNGLISFENCEAPPLEPROC', 'PFNGLTESTFENCEAPPLEPROC',
'PFNGLFINISHFENCEAPPLEPROC', 'PFNGLTESTOBJECTAPPLEPROC',
'PFNGLFINISHOBJECTAPPLEPROC', 'GL_APPLE_vertex_array_object',
'glBindVertexArrayAPPLE', 'glDeleteVertexArraysAPPLE',
'glGenVertexArraysAPPLE', 'glIsVertexArrayAPPLE',
'PFNGLBINDVERTEXARRAYAPPLEPROC', 'PFNGLDELETEVERTEXARRAYSAPPLEPROC',
'PFNGLGENVERTEXARRAYSAPPLEPROC', 'PFNGLISVERTEXARRAYAPPLEPROC',
'GL_APPLE_vertex_array_range', 'glVertexArrayRangeAPPLE',
'glFlushVertexArrayRangeAPPLE', 'glVertexArrayParameteriAPPLE',
'PFNGLVERTEXARRAYRANGEAPPLEPROC', 'PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC',
'PFNGLVERTEXARRAYPARAMETERIAPPLEPROC', 'GL_APPLE_ycbcr_422', 'GL_S3_s3tc',
'GL_ATI_draw_buffers', 'glDrawBuffersATI', 'PFNGLDRAWBUFFERSATIPROC',
'GL_ATI_pixel_format_float', 'GL_ATI_texture_env_combine3',
'GL_ATI_texture_float', 'GL_NV_float_buffer', 'GL_NV_fragment_program',
'glProgramNamedParameter4fNV', 'glProgramNamedParameter4dNV',
'glProgramNamedParameter4fvNV', 'glProgramNamedParameter4dvNV',
'glGetProgramNamedParameterfvNV', 'glGetProgramNamedParameterdvNV',
'PFNGLPROGRAMNAMEDPARAMETER4FNVPROC', 'PFNGLPROGRAMNAMEDPARAMETER4DNVPROC',
'PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC', 'PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC',
'PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC',
'PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC', 'GL_NV_half_float', 'glVertex2hNV',
'glVertex2hvNV', 'glVertex3hNV', 'glVertex3hvNV', 'glVertex4hNV',
'glVertex4hvNV', 'glNormal3hNV', 'glNormal3hvNV', 'glColor3hNV',
'glColor3hvNV', 'glColor4hNV', 'glColor4hvNV', 'glTexCoord1hNV',
'glTexCoord1hvNV', 'glTexCoord2hNV', 'glTexCoord2hvNV', 'glTexCoord3hNV',
'glTexCoord3hvNV', 'glTexCoord4hNV', 'glTexCoord4hvNV', 'glMultiTexCoord1hNV',
'glMultiTexCoord1hvNV', 'glMultiTexCoord2hNV', 'glMultiTexCoord2hvNV',
'glMultiTexCoord3hNV', 'glMultiTexCoord3hvNV', 'glMultiTexCoord4hNV',
'glMultiTexCoord4hvNV', 'glFogCoordhNV', 'glFogCoordhvNV',
'glSecondaryColor3hNV', 'glSecondaryColor3hvNV', 'glVertexWeighthNV',
'glVertexWeighthvNV', 'glVertexAttrib1hNV', 'glVertexAttrib1hvNV',
'glVertexAttrib2hNV', 'glVertexAttrib2hvNV', 'glVertexAttrib3hNV',
'glVertexAttrib3hvNV', 'glVertexAttrib4hNV', 'glVertexAttrib4hvNV',
'glVertexAttribs1hvNV', 'glVertexAttribs2hvNV', 'glVertexAttribs3hvNV',
'glVertexAttribs4hvNV', 'PFNGLVERTEX2HNVPROC', 'PFNGLVERTEX2HVNVPROC',
'PFNGLVERTEX3HNVPROC', 'PFNGLVERTEX3HVNVPROC', 'PFNGLVERTEX4HNVPROC',
'PFNGLVERTEX4HVNVPROC', 'PFNGLNORMAL3HNVPROC', 'PFNGLNORMAL3HVNVPROC',
'PFNGLCOLOR3HNVPROC', 'PFNGLCOLOR3HVNVPROC', 'PFNGLCOLOR4HNVPROC',
'PFNGLCOLOR4HVNVPROC', 'PFNGLTEXCOORD1HNVPROC', 'PFNGLTEXCOORD1HVNVPROC',
'PFNGLTEXCOORD2HNVPROC', 'PFNGLTEXCOORD2HVNVPROC', 'PFNGLTEXCOORD3HNVPROC',
'PFNGLTEXCOORD3HVNVPROC', 'PFNGLTEXCOORD4HNVPROC', 'PFNGLTEXCOORD4HVNVPROC',
'PFNGLMULTITEXCOORD1HNVPROC', 'PFNGLMULTITEXCOORD1HVNVPROC',
'PFNGLMULTITEXCOORD2HNVPROC', 'PFNGLMULTITEXCOORD2HVNVPROC',
'PFNGLMULTITEXCOORD3HNVPROC', 'PFNGLMULTITEXCOORD3HVNVPROC',
'PFNGLMULTITEXCOORD4HNVPROC', 'PFNGLMULTITEXCOORD4HVNVPROC',
'PFNGLFOGCOORDHNVPROC', 'PFNGLFOGCOORDHVNVPROC',
'PFNGLSECONDARYCOLOR3HNVPROC', 'PFNGLSECONDARYCOLOR3HVNVPROC',
'PFNGLVERTEXWEIGHTHNVPROC', 'PFNGLVERTEXWEIGHTHVNVPROC',
'PFNGLVERTEXATTRIB1HNVPROC', 'PFNGLVERTEXATTRIB1HVNVPROC',
'PFNGLVERTEXATTRIB2HNVPROC', 'PFNGLVERTEXATTRIB2HVNVPROC',
'PFNGLVERTEXATTRIB3HNVPROC', 'PFNGLVERTEXATTRIB3HVNVPROC',
'PFNGLVERTEXATTRIB4HNVPROC', 'PFNGLVERTEXATTRIB4HVNVPROC',
'PFNGLVERTEXATTRIBS1HVNVPROC', 'PFNGLVERTEXATTRIBS2HVNVPROC',
'PFNGLVERTEXATTRIBS3HVNVPROC', 'PFNGLVERTEXATTRIBS4HVNVPROC',
'GL_NV_pixel_data_range', 'glPixelDataRangeNV', 'glFlushPixelDataRangeNV',
'PFNGLPIXELDATARANGENVPROC', 'PFNGLFLUSHPIXELDATARANGENVPROC',
'GL_NV_primitive_restart', 'glPrimitiveRestartNV',
'glPrimitiveRestartIndexNV', 'PFNGLPRIMITIVERESTARTNVPROC',
'PFNGLPRIMITIVERESTARTINDEXNVPROC', 'GL_NV_texture_expand_normal',
'GL_NV_vertex_program2', 'GL_ATI_map_object_buffer', 'glMapObjectBufferATI',
'glUnmapObjectBufferATI', 'PFNGLMAPOBJECTBUFFERATIPROC',
'PFNGLUNMAPOBJECTBUFFERATIPROC', 'GL_ATI_separate_stencil',
'glStencilOpSeparateATI', 'glStencilFuncSeparateATI',
'PFNGLSTENCILOPSEPARATEATIPROC', 'PFNGLSTENCILFUNCSEPARATEATIPROC',
'GL_ATI_vertex_attrib_array_object', 'glVertexAttribArrayObjectATI',
'glGetVertexAttribArrayObjectfvATI', 'glGetVertexAttribArrayObjectivATI',
'PFNGLVERTEXATTRIBARRAYOBJECTATIPROC',
'PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC',
'PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC', 'GL_OES_read_format',
'GL_EXT_depth_bounds_test', 'glDepthBoundsEXT', 'PFNGLDEPTHBOUNDSEXTPROC',
'GL_EXT_texture_mirror_clamp', 'GL_EXT_blend_equation_separate',
'glBlendEquationSeparateEXT', 'PFNGLBLENDEQUATIONSEPARATEEXTPROC',
'GL_MESA_pack_invert', 'GL_MESA_ycbcr_texture', 'GL_EXT_pixel_buffer_object',
'GL_NV_fragment_program_option', 'GL_NV_fragment_program2',
'GL_NV_vertex_program2_option', 'GL_NV_vertex_program3',
'GL_EXT_framebuffer_object', 'glIsRenderbufferEXT', 'glBindRenderbufferEXT',
'glDeleteRenderbuffersEXT', 'glGenRenderbuffersEXT',
'glRenderbufferStorageEXT', 'glGetRenderbufferParameterivEXT',
'glIsFramebufferEXT', 'glBindFramebufferEXT', 'glDeleteFramebuffersEXT',
'glGenFramebuffersEXT', 'glCheckFramebufferStatusEXT',
'glFramebufferTexture1DEXT', 'glFramebufferTexture2DEXT',
'glFramebufferTexture3DEXT', 'glFramebufferRenderbufferEXT',
'glGetFramebufferAttachmentParameterivEXT', 'glGenerateMipmapEXT',
'PFNGLISRENDERBUFFEREXTPROC', 'PFNGLBINDRENDERBUFFEREXTPROC',
'PFNGLDELETERENDERBUFFERSEXTPROC', 'PFNGLGENRENDERBUFFERSEXTPROC',
'PFNGLRENDERBUFFERSTORAGEEXTPROC', 'PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC',
'PFNGLISFRAMEBUFFEREXTPROC', 'PFNGLBINDFRAMEBUFFEREXTPROC',
'PFNGLDELETEFRAMEBUFFERSEXTPROC', 'PFNGLGENFRAMEBUFFERSEXTPROC',
'PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC', 'PFNGLFRAMEBUFFERTEXTURE1DEXTPROC',
'PFNGLFRAMEBUFFERTEXTURE2DEXTPROC', 'PFNGLFRAMEBUFFERTEXTURE3DEXTPROC',
'PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC',
'PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC',
'PFNGLGENERATEMIPMAPEXTPROC', 'GL_GREMEDY_string_marker',
'glStringMarkerGREMEDY', 'PFNGLSTRINGMARKERGREMEDYPROC', 'GL_EXT_Cg_shader',
'GL_EXT_timer_query', 'glGetQueryObjecti64vEXT', 'glGetQueryObjectui64vEXT',
'PFNGLGETQUERYOBJECTI64VEXTPROC', 'PFNGLGETQUERYOBJECTUI64VEXTPROC',
'GL_EXT_texture_buffer_object', 'glTexBufferEXT', 'PFNGLTEXBUFFEREXTPROC',
'GL_NV_transform_feedback', 'glBeginTransformFeedbackNV',
'glEndTransformFeedbackNV', 'glTransformFeedbackAttribsNV',
'glBindBufferRangeNV', 'glBindBufferOffsetNV', 'glBindBufferBaseNV',
'glTransformFeedbackVaryingsNV', 'glActiveVaryingNV',
'glGetVaryingLocationNV', 'glGetActiveVaryingNV',
'glGetTransformFeedbackVaryingNV', 'PFNGLBEGINTRANSFORMFEEDBACKNVPROC',
'PFNGLENDTRANSFORMFEEDBACKNVPROC', 'PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC',
'PFNGLBINDBUFFERRANGENVPROC', 'PFNGLBINDBUFFEROFFSETNVPROC',
'PFNGLBINDBUFFERBASENVPROC', 'PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC',
'PFNGLACTIVEVARYINGNVPROC', 'PFNGLGETVARYINGLOCATIONNVPROC',
'PFNGLGETACTIVEVARYINGNVPROC', 'PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC',
'GL_NV_depth_buffer_float', 'glDepthRangedNV', 'glClearDepthdNV',
'glDepthBoundsdNV', 'PFNGLDEPTHRANGEDNVPROC', 'PFNGLCLEARDEPTHDNVPROC',
'PFNGLDEPTHBOUNDSDNVPROC', 'GL_EXT_texture_compression_latc',
'GL_EXT_framebuffer_sRGB', 'GL_EXT_texture_shared_exponent',
'GL_EXT_packed_float', 'GL_EXT_texture_array', 'GL_EXT_draw_buffers2',
'glColorMaskIndexedEXT', 'glGetBooleanIndexedvEXT', 'glGetIntegerIndexedvEXT',
'glEnableIndexedEXT', 'glDisableIndexedEXT', 'glIsEnabledIndexedEXT',
'PFNGLCOLORMASKINDEXEDEXTPROC', 'PFNGLGETBOOLEANINDEXEDVEXTPROC',
'PFNGLGETINTEGERINDEXEDVEXTPROC', 'PFNGLENABLEINDEXEDEXTPROC',
'PFNGLDISABLEINDEXEDEXTPROC', 'PFNGLISENABLEDINDEXEDEXTPROC',
'GL_EXT_texture_integer', 'glTexParameterIivEXT', 'glTexParameterIuivEXT',
'glGetTexParameterIivEXT', 'glGetTexParameterIuivEXT', 'glClearColorIiEXT',
'glClearColorIuiEXT', 'PFNGLTEXPARAMETERIIVEXTPROC',
'PFNGLTEXPARAMETERIUIVEXTPROC', 'PFNGLGETTEXPARAMETERIIVEXTPROC',
'PFNGLGETTEXPARAMETERIUIVEXTPROC', 'PFNGLCLEARCOLORIIEXTPROC',
'PFNGLCLEARCOLORIUIEXTPROC', 'GL_EXT_bindable_uniform', 'glUniformBufferEXT',
'glGetUniformBufferSizeEXT', 'glGetUniformOffsetEXT',
'PFNGLUNIFORMBUFFEREXTPROC', 'PFNGLGETUNIFORMBUFFERSIZEEXTPROC',
'PFNGLGETUNIFORMOFFSETEXTPROC', 'GL_EXT_gpu_shader4', 'glGetUniformuivEXT',
'glBindFragDataLocationEXT', 'glGetFragDataLocationEXT', 'glUniform1uiEXT',
'glUniform2uiEXT', 'glUniform3uiEXT', 'glUniform4uiEXT', 'glUniform1uivEXT',
'glUniform2uivEXT', 'glUniform3uivEXT', 'glUniform4uivEXT',
'glVertexAttribI1iEXT', 'glVertexAttribI2iEXT', 'glVertexAttribI3iEXT',
'glVertexAttribI4iEXT', 'glVertexAttribI1uiEXT', 'glVertexAttribI2uiEXT',
'glVertexAttribI3uiEXT', 'glVertexAttribI4uiEXT', 'glVertexAttribI1ivEXT',
'glVertexAttribI2ivEXT', 'glVertexAttribI3ivEXT', 'glVertexAttribI4ivEXT',
'glVertexAttribI1uivEXT', 'glVertexAttribI2uivEXT', 'glVertexAttribI3uivEXT',
'glVertexAttribI4uivEXT', 'glVertexAttribI4bvEXT', 'glVertexAttribI4svEXT',
'glVertexAttribI4ubvEXT', 'glVertexAttribI4usvEXT',
'glVertexAttribIPointerEXT', 'glGetVertexAttribIivEXT',
'glGetVertexAttribIuivEXT', 'PFNGLGETUNIFORMUIVEXTPROC',
'PFNGLBINDFRAGDATALOCATIONEXTPROC', 'PFNGLGETFRAGDATALOCATIONEXTPROC',
'PFNGLUNIFORM1UIEXTPROC', 'PFNGLUNIFORM2UIEXTPROC', 'PFNGLUNIFORM3UIEXTPROC',
'PFNGLUNIFORM4UIEXTPROC', 'PFNGLUNIFORM1UIVEXTPROC',
'PFNGLUNIFORM2UIVEXTPROC', 'PFNGLUNIFORM3UIVEXTPROC',
'PFNGLUNIFORM4UIVEXTPROC', 'PFNGLVERTEXATTRIBI1IEXTPROC',
'PFNGLVERTEXATTRIBI2IEXTPROC', 'PFNGLVERTEXATTRIBI3IEXTPROC',
'PFNGLVERTEXATTRIBI4IEXTPROC', 'PFNGLVERTEXATTRIBI1UIEXTPROC',
'PFNGLVERTEXATTRIBI2UIEXTPROC', 'PFNGLVERTEXATTRIBI3UIEXTPROC',
'PFNGLVERTEXATTRIBI4UIEXTPROC', 'PFNGLVERTEXATTRIBI1IVEXTPROC',
'PFNGLVERTEXATTRIBI2IVEXTPROC', 'PFNGLVERTEXATTRIBI3IVEXTPROC',
'PFNGLVERTEXATTRIBI4IVEXTPROC', 'PFNGLVERTEXATTRIBI1UIVEXTPROC',
'PFNGLVERTEXATTRIBI2UIVEXTPROC', 'PFNGLVERTEXATTRIBI3UIVEXTPROC',
'PFNGLVERTEXATTRIBI4UIVEXTPROC', 'PFNGLVERTEXATTRIBI4BVEXTPROC',
'PFNGLVERTEXATTRIBI4SVEXTPROC', 'PFNGLVERTEXATTRIBI4UBVEXTPROC',
'PFNGLVERTEXATTRIBI4USVEXTPROC', 'PFNGLVERTEXATTRIBIPOINTEREXTPROC',
'PFNGLGETVERTEXATTRIBIIVEXTPROC', 'PFNGLGETVERTEXATTRIBIUIVEXTPROC',
'GL_EXT_geometry_shader4', 'glProgramParameteriEXT',
'glFramebufferTextureEXT', 'glFramebufferTextureLayerEXT',
'glFramebufferTextureFaceEXT', 'PFNGLPROGRAMPARAMETERIEXTPROC',
'PFNGLFRAMEBUFFERTEXTUREEXTPROC', 'PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC',
'PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC', 'GL_NV_geometry_program4',
'glProgramVertexLimitNV', 'PFNGLPROGRAMVERTEXLIMITNVPROC',
'GL_NV_gpu_program4', 'glProgramLocalParameterI4iNV',
'glProgramLocalParameterI4ivNV', 'glProgramLocalParametersI4ivNV',
'glProgramLocalParameterI4uiNV', 'glProgramLocalParameterI4uivNV',
'glProgramLocalParametersI4uivNV', 'glProgramEnvParameterI4iNV',
'glProgramEnvParameterI4ivNV', 'glProgramEnvParametersI4ivNV',
'glProgramEnvParameterI4uiNV', 'glProgramEnvParameterI4uivNV',
'glProgramEnvParametersI4uivNV', 'glGetProgramLocalParameterIivNV',
'glGetProgramLocalParameterIuivNV', 'glGetProgramEnvParameterIivNV',
'glGetProgramEnvParameterIuivNV', 'PFNGLPROGRAMLOCALPARAMETERI4INVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4UINVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC', 'PFNGLPROGRAMENVPARAMETERI4INVPROC',
'PFNGLPROGRAMENVPARAMETERI4IVNVPROC', 'PFNGLPROGRAMENVPARAMETERSI4IVNVPROC',
'PFNGLPROGRAMENVPARAMETERI4UINVPROC', 'PFNGLPROGRAMENVPARAMETERI4UIVNVPROC',
'PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC',
'PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC',
'PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC',
'PFNGLGETPROGRAMENVPARAMETERIIVNVPROC',
'PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC', 'GL_NV_parameter_buffer_object',
'glProgramBufferParametersfvNV', 'glProgramBufferParametersIivNV',
'glProgramBufferParametersIuivNV', 'PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC',
'PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC',
'PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC', 'GL_EXT_framebuffer_multisample',
'glRenderbufferStorageMultisampleEXT',
'PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC',
'GL_NV_framebuffer_multisample_coverage',
'glRenderbufferStorageMultisampleCoverageNV',
'PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC',
'GL_EXT_framebuffer_blit', 'glBlitFramebufferEXT',
'PFNGLBLITFRAMEBUFFEREXTPROC', 'GL_EXT_draw_instanced',
'glDrawArraysInstancedEXT', 'glDrawElementsInstancedEXT',
'PFNGLDRAWARRAYSINSTANCEDEXTPROC', 'PFNGLDRAWELEMENTSINSTANCEDEXTPROC',
'GL_EXT_texture_compression_rgtc', 'GL_NV_present_video',
'glPresentFrameKeyedNV', 'glPresentFrameDualFillNV', 'glGetVideoivNV',
'glGetVideouivNV', 'glGetVideoi64vNV', 'glGetVideoui64vNV',
'PFNGLPRESENTFRAMEKEYEDNVPROC', 'PFNGLPRESENTFRAMEDUALFILLNVPROC',
'PFNGLGETVIDEOIVNVPROC', 'PFNGLGETVIDEOUIVNVPROC', 'PFNGLGETVIDEOI64VNVPROC',
'PFNGLGETVIDEOUI64VNVPROC', 'GL_NV_conditional_render',
'glBeginConditionalRenderNV', 'glEndConditionalRenderNV',
'PFNGLBEGINCONDITIONALRENDERNVPROC', 'PFNGLENDCONDITIONALRENDERNVPROC',
'GL_EXT_transform_feedback', 'glBeginTransformFeedbackEXT',
'glEndTransformFeedbackEXT', 'glBindBufferRangeEXT', 'glBindBufferOffsetEXT',
'glBindBufferBaseEXT', 'glTransformFeedbackVaryingsEXT',
'glGetTransformFeedbackVaryingEXT', 'PFNGLBEGINTRANSFORMFEEDBACKEXTPROC',
'PFNGLENDTRANSFORMFEEDBACKEXTPROC', 'PFNGLBINDBUFFERRANGEEXTPROC',
'PFNGLBINDBUFFEROFFSETEXTPROC', 'PFNGLBINDBUFFERBASEEXTPROC',
'PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC',
'PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC', 'GL_EXT_direct_state_access',
'glClientAttribDefaultEXT', 'glPushClientAttribDefaultEXT',
'glMatrixLoadfEXT', 'glMatrixLoaddEXT', 'glMatrixMultfEXT',
'glMatrixMultdEXT', 'glMatrixLoadIdentityEXT', 'glMatrixRotatefEXT',
'glMatrixRotatedEXT', 'glMatrixScalefEXT', 'glMatrixScaledEXT',
'glMatrixTranslatefEXT', 'glMatrixTranslatedEXT', 'glMatrixFrustumEXT',
'glMatrixOrthoEXT', 'glMatrixPopEXT', 'glMatrixPushEXT',
'glMatrixLoadTransposefEXT', 'glMatrixLoadTransposedEXT',
'glMatrixMultTransposefEXT', 'glMatrixMultTransposedEXT',
'glTextureParameterfEXT', 'glTextureParameterfvEXT', 'glTextureParameteriEXT',
'glTextureParameterivEXT', 'glTextureImage1DEXT', 'glTextureImage2DEXT',
'glTextureSubImage1DEXT', 'glTextureSubImage2DEXT', 'glCopyTextureImage1DEXT',
'glCopyTextureImage2DEXT', 'glCopyTextureSubImage1DEXT',
'glCopyTextureSubImage2DEXT', 'glGetTextureImageEXT',
'glGetTextureParameterfvEXT', 'glGetTextureParameterivEXT',
'glGetTextureLevelParameterfvEXT', 'glGetTextureLevelParameterivEXT',
'glTextureImage3DEXT', 'glTextureSubImage3DEXT', 'glCopyTextureSubImage3DEXT',
'glMultiTexParameterfEXT', 'glMultiTexParameterfvEXT',
'glMultiTexParameteriEXT', 'glMultiTexParameterivEXT', 'glMultiTexImage1DEXT',
'glMultiTexImage2DEXT', 'glMultiTexSubImage1DEXT', 'glMultiTexSubImage2DEXT',
'glCopyMultiTexImage1DEXT', 'glCopyMultiTexImage2DEXT',
'glCopyMultiTexSubImage1DEXT', 'glCopyMultiTexSubImage2DEXT',
'glGetMultiTexImageEXT', 'glGetMultiTexParameterfvEXT',
'glGetMultiTexParameterivEXT', 'glGetMultiTexLevelParameterfvEXT',
'glGetMultiTexLevelParameterivEXT', 'glMultiTexImage3DEXT',
'glMultiTexSubImage3DEXT', 'glCopyMultiTexSubImage3DEXT',
'glBindMultiTextureEXT', 'glEnableClientStateIndexedEXT',
'glDisableClientStateIndexedEXT', 'glMultiTexCoordPointerEXT',
'glMultiTexEnvfEXT', 'glMultiTexEnvfvEXT', 'glMultiTexEnviEXT',
'glMultiTexEnvivEXT', 'glMultiTexGendEXT', 'glMultiTexGendvEXT',
'glMultiTexGenfEXT', 'glMultiTexGenfvEXT', 'glMultiTexGeniEXT',
'glMultiTexGenivEXT', 'glGetMultiTexEnvfvEXT', 'glGetMultiTexEnvivEXT',
'glGetMultiTexGendvEXT', 'glGetMultiTexGenfvEXT', 'glGetMultiTexGenivEXT',
'glGetFloatIndexedvEXT', 'glGetDoubleIndexedvEXT', 'glGetPointerIndexedvEXT',
'glCompressedTextureImage3DEXT', 'glCompressedTextureImage2DEXT',
'glCompressedTextureImage1DEXT', 'glCompressedTextureSubImage3DEXT',
'glCompressedTextureSubImage2DEXT', 'glCompressedTextureSubImage1DEXT',
'glGetCompressedTextureImageEXT', 'glCompressedMultiTexImage3DEXT',
'glCompressedMultiTexImage2DEXT', 'glCompressedMultiTexImage1DEXT',
'glCompressedMultiTexSubImage3DEXT', 'glCompressedMultiTexSubImage2DEXT',
'glCompressedMultiTexSubImage1DEXT', 'glGetCompressedMultiTexImageEXT',
'glNamedProgramStringEXT', 'glNamedProgramLocalParameter4dEXT',
'glNamedProgramLocalParameter4dvEXT', 'glNamedProgramLocalParameter4fEXT',
'glNamedProgramLocalParameter4fvEXT', 'glGetNamedProgramLocalParameterdvEXT',
'glGetNamedProgramLocalParameterfvEXT', 'glGetNamedProgramivEXT',
'glGetNamedProgramStringEXT', 'glNamedProgramLocalParameters4fvEXT',
'glNamedProgramLocalParameterI4iEXT', 'glNamedProgramLocalParameterI4ivEXT',
'glNamedProgramLocalParametersI4ivEXT', 'glNamedProgramLocalParameterI4uiEXT',
'glNamedProgramLocalParameterI4uivEXT',
'glNamedProgramLocalParametersI4uivEXT',
'glGetNamedProgramLocalParameterIivEXT',
'glGetNamedProgramLocalParameterIuivEXT', 'glTextureParameterIivEXT',
'glTextureParameterIuivEXT', 'glGetTextureParameterIivEXT',
'glGetTextureParameterIuivEXT', 'glMultiTexParameterIivEXT',
'glMultiTexParameterIuivEXT', 'glGetMultiTexParameterIivEXT',
'glGetMultiTexParameterIuivEXT', 'glProgramUniform1fEXT',
'glProgramUniform2fEXT', 'glProgramUniform3fEXT', 'glProgramUniform4fEXT',
'glProgramUniform1iEXT', 'glProgramUniform2iEXT', 'glProgramUniform3iEXT',
'glProgramUniform4iEXT', 'glProgramUniform1fvEXT', 'glProgramUniform2fvEXT',
'glProgramUniform3fvEXT', 'glProgramUniform4fvEXT', 'glProgramUniform1ivEXT',
'glProgramUniform2ivEXT', 'glProgramUniform3ivEXT', 'glProgramUniform4ivEXT',
'glProgramUniformMatrix2fvEXT', 'glProgramUniformMatrix3fvEXT',
'glProgramUniformMatrix4fvEXT', 'glProgramUniformMatrix2x3fvEXT',
'glProgramUniformMatrix3x2fvEXT', 'glProgramUniformMatrix2x4fvEXT',
'glProgramUniformMatrix4x2fvEXT', 'glProgramUniformMatrix3x4fvEXT',
'glProgramUniformMatrix4x3fvEXT', 'glProgramUniform1uiEXT',
'glProgramUniform2uiEXT', 'glProgramUniform3uiEXT', 'glProgramUniform4uiEXT',
'glProgramUniform1uivEXT', 'glProgramUniform2uivEXT',
'glProgramUniform3uivEXT', 'glProgramUniform4uivEXT', 'glNamedBufferDataEXT',
'glNamedBufferSubDataEXT', 'glMapNamedBufferEXT', 'glUnmapNamedBufferEXT',
'glGetNamedBufferParameterivEXT', 'glGetNamedBufferPointervEXT',
'glGetNamedBufferSubDataEXT', 'glTextureBufferEXT', 'glMultiTexBufferEXT',
'glNamedRenderbufferStorageEXT', 'glGetNamedRenderbufferParameterivEXT',
'glCheckNamedFramebufferStatusEXT', 'glNamedFramebufferTexture1DEXT',
'glNamedFramebufferTexture2DEXT', 'glNamedFramebufferTexture3DEXT',
'glNamedFramebufferRenderbufferEXT',
'glGetNamedFramebufferAttachmentParameterivEXT', 'glGenerateTextureMipmapEXT',
'glGenerateMultiTexMipmapEXT', 'glFramebufferDrawBufferEXT',
'glFramebufferDrawBuffersEXT', 'glFramebufferReadBufferEXT',
'glGetFramebufferParameterivEXT', 'glNamedRenderbufferStorageMultisampleEXT',
'glNamedRenderbufferStorageMultisampleCoverageEXT',
'glNamedFramebufferTextureEXT', 'glNamedFramebufferTextureLayerEXT',
'glNamedFramebufferTextureFaceEXT', 'glTextureRenderbufferEXT',
'glMultiTexRenderbufferEXT', 'PFNGLCLIENTATTRIBDEFAULTEXTPROC',
'PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC', 'PFNGLMATRIXLOADFEXTPROC',
'PFNGLMATRIXLOADDEXTPROC', 'PFNGLMATRIXMULTFEXTPROC',
'PFNGLMATRIXMULTDEXTPROC', 'PFNGLMATRIXLOADIDENTITYEXTPROC',
'PFNGLMATRIXROTATEFEXTPROC', 'PFNGLMATRIXROTATEDEXTPROC',
'PFNGLMATRIXSCALEFEXTPROC', 'PFNGLMATRIXSCALEDEXTPROC',
'PFNGLMATRIXTRANSLATEFEXTPROC', 'PFNGLMATRIXTRANSLATEDEXTPROC',
'PFNGLMATRIXFRUSTUMEXTPROC', 'PFNGLMATRIXORTHOEXTPROC',
'PFNGLMATRIXPOPEXTPROC', 'PFNGLMATRIXPUSHEXTPROC',
'PFNGLMATRIXLOADTRANSPOSEFEXTPROC', 'PFNGLMATRIXLOADTRANSPOSEDEXTPROC',
'PFNGLMATRIXMULTTRANSPOSEFEXTPROC', 'PFNGLMATRIXMULTTRANSPOSEDEXTPROC',
'PFNGLTEXTUREPARAMETERFEXTPROC', 'PFNGLTEXTUREPARAMETERFVEXTPROC',
'PFNGLTEXTUREPARAMETERIEXTPROC', 'PFNGLTEXTUREPARAMETERIVEXTPROC',
'PFNGLTEXTUREIMAGE1DEXTPROC', 'PFNGLTEXTUREIMAGE2DEXTPROC',
'PFNGLTEXTURESUBIMAGE1DEXTPROC', 'PFNGLTEXTURESUBIMAGE2DEXTPROC',
'PFNGLCOPYTEXTUREIMAGE1DEXTPROC', 'PFNGLCOPYTEXTUREIMAGE2DEXTPROC',
'PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC', 'PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC',
'PFNGLGETTEXTUREIMAGEEXTPROC', 'PFNGLGETTEXTUREPARAMETERFVEXTPROC',
'PFNGLGETTEXTUREPARAMETERIVEXTPROC', 'PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC',
'PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC', 'PFNGLTEXTUREIMAGE3DEXTPROC',
'PFNGLTEXTURESUBIMAGE3DEXTPROC', 'PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC',
'PFNGLMULTITEXPARAMETERFEXTPROC', 'PFNGLMULTITEXPARAMETERFVEXTPROC',
'PFNGLMULTITEXPARAMETERIEXTPROC', 'PFNGLMULTITEXPARAMETERIVEXTPROC',
'PFNGLMULTITEXIMAGE1DEXTPROC', 'PFNGLMULTITEXIMAGE2DEXTPROC',
'PFNGLMULTITEXSUBIMAGE1DEXTPROC', 'PFNGLMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLCOPYMULTITEXIMAGE1DEXTPROC', 'PFNGLCOPYMULTITEXIMAGE2DEXTPROC',
'PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC', 'PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLGETMULTITEXIMAGEEXTPROC', 'PFNGLGETMULTITEXPARAMETERFVEXTPROC',
'PFNGLGETMULTITEXPARAMETERIVEXTPROC',
'PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC',
'PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC', 'PFNGLMULTITEXIMAGE3DEXTPROC',
'PFNGLMULTITEXSUBIMAGE3DEXTPROC', 'PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC',
'PFNGLBINDMULTITEXTUREEXTPROC', 'PFNGLENABLECLIENTSTATEINDEXEDEXTPROC',
'PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC', 'PFNGLMULTITEXCOORDPOINTEREXTPROC',
'PFNGLMULTITEXENVFEXTPROC', 'PFNGLMULTITEXENVFVEXTPROC',
'PFNGLMULTITEXENVIEXTPROC', 'PFNGLMULTITEXENVIVEXTPROC',
'PFNGLMULTITEXGENDEXTPROC', 'PFNGLMULTITEXGENDVEXTPROC',
'PFNGLMULTITEXGENFEXTPROC', 'PFNGLMULTITEXGENFVEXTPROC',
'PFNGLMULTITEXGENIEXTPROC', 'PFNGLMULTITEXGENIVEXTPROC',
'PFNGLGETMULTITEXENVFVEXTPROC', 'PFNGLGETMULTITEXENVIVEXTPROC',
'PFNGLGETMULTITEXGENDVEXTPROC', 'PFNGLGETMULTITEXGENFVEXTPROC',
'PFNGLGETMULTITEXGENIVEXTPROC', 'PFNGLGETFLOATINDEXEDVEXTPROC',
'PFNGLGETDOUBLEINDEXEDVEXTPROC', 'PFNGLGETPOINTERINDEXEDVEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC',
'PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC',
'PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC', 'PFNGLNAMEDPROGRAMSTRINGEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC',
'PFNGLGETNAMEDPROGRAMIVEXTPROC', 'PFNGLGETNAMEDPROGRAMSTRINGEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC',
'PFNGLTEXTUREPARAMETERIIVEXTPROC', 'PFNGLTEXTUREPARAMETERIUIVEXTPROC',
'PFNGLGETTEXTUREPARAMETERIIVEXTPROC', 'PFNGLGETTEXTUREPARAMETERIUIVEXTPROC',
'PFNGLMULTITEXPARAMETERIIVEXTPROC', 'PFNGLMULTITEXPARAMETERIUIVEXTPROC',
'PFNGLGETMULTITEXPARAMETERIIVEXTPROC', 'PFNGLGETMULTITEXPARAMETERIUIVEXTPROC',
'PFNGLPROGRAMUNIFORM1FEXTPROC', 'PFNGLPROGRAMUNIFORM2FEXTPROC',
'PFNGLPROGRAMUNIFORM3FEXTPROC', 'PFNGLPROGRAMUNIFORM4FEXTPROC',
'PFNGLPROGRAMUNIFORM1IEXTPROC', 'PFNGLPROGRAMUNIFORM2IEXTPROC',
'PFNGLPROGRAMUNIFORM3IEXTPROC', 'PFNGLPROGRAMUNIFORM4IEXTPROC',
'PFNGLPROGRAMUNIFORM1FVEXTPROC', 'PFNGLPROGRAMUNIFORM2FVEXTPROC',
'PFNGLPROGRAMUNIFORM3FVEXTPROC', 'PFNGLPROGRAMUNIFORM4FVEXTPROC',
'PFNGLPROGRAMUNIFORM1IVEXTPROC', 'PFNGLPROGRAMUNIFORM2IVEXTPROC',
'PFNGLPROGRAMUNIFORM3IVEXTPROC', 'PFNGLPROGRAMUNIFORM4IVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC', 'PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC', 'PFNGLPROGRAMUNIFORM1UIEXTPROC',
'PFNGLPROGRAMUNIFORM2UIEXTPROC', 'PFNGLPROGRAMUNIFORM3UIEXTPROC',
'PFNGLPROGRAMUNIFORM4UIEXTPROC', 'PFNGLPROGRAMUNIFORM1UIVEXTPROC',
'PFNGLPROGRAMUNIFORM2UIVEXTPROC', 'PFNGLPROGRAMUNIFORM3UIVEXTPROC',
'PFNGLPROGRAMUNIFORM4UIVEXTPROC', 'PFNGLNAMEDBUFFERDATAEXTPROC',
'PFNGLNAMEDBUFFERSUBDATAEXTPROC', 'PFNGLMAPNAMEDBUFFEREXTPROC',
'PFNGLUNMAPNAMEDBUFFEREXTPROC', 'PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC',
'PFNGLGETNAMEDBUFFERPOINTERVEXTPROC', 'PFNGLGETNAMEDBUFFERSUBDATAEXTPROC',
'PFNGLTEXTUREBUFFEREXTPROC', 'PFNGLMULTITEXBUFFEREXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC',
'PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC',
'PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC',
'PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC',
'PFNGLGENERATETEXTUREMIPMAPEXTPROC', 'PFNGLGENERATEMULTITEXMIPMAPEXTPROC',
'PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC', 'PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC',
'PFNGLFRAMEBUFFERREADBUFFEREXTPROC', 'PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC', 'PFNGLTEXTURERENDERBUFFEREXTPROC',
'PFNGLMULTITEXRENDERBUFFEREXTPROC', 'GL_EXT_vertex_array_bgra',
'GL_EXT_texture_swizzle', 'GL_NV_explicit_multisample',
'glGetMultisamplefvNV', 'glSampleMaskIndexedNV', 'glTexRenderbufferNV',
'PFNGLGETMULTISAMPLEFVNVPROC', 'PFNGLSAMPLEMASKINDEXEDNVPROC',
'PFNGLTEXRENDERBUFFERNVPROC', 'GL_NV_transform_feedback2',
'glBindTransformFeedbackNV', 'glDeleteTransformFeedbacksNV',
'glGenTransformFeedbacksNV', 'glIsTransformFeedbackNV',
'glPauseTransformFeedbackNV', 'glResumeTransformFeedbackNV',
'glDrawTransformFeedbackNV', 'PFNGLBINDTRANSFORMFEEDBACKNVPROC',
'PFNGLDELETETRANSFORMFEEDBACKSNVPROC', 'PFNGLGENTRANSFORMFEEDBACKSNVPROC',
'PFNGLISTRANSFORMFEEDBACKNVPROC', 'PFNGLPAUSETRANSFORMFEEDBACKNVPROC',
'PFNGLRESUMETRANSFORMFEEDBACKNVPROC', 'PFNGLDRAWTRANSFORMFEEDBACKNVPROC',
'GL_NV_vertex_buffer_unified_memory', 'glBufferAddressRangeNV',
'glVertexFormatNV', 'glNormalFormatNV', 'glColorFormatNV', 'glIndexFormatNV',
'glTexCoordFormatNV', 'glEdgeFlagFormatNV', 'glSecondaryColorFormatNV',
'glFogCoordFormatNV', 'glVertexAttribFormatNV', 'glVertexAttribIFormatNV',
'glGetIntegerui64i_vNV', 'PFNGLBUFFERADDRESSRANGENVPROC',
'PFNGLVERTEXFORMATNVPROC', 'PFNGLNORMALFORMATNVPROC',
'PFNGLCOLORFORMATNVPROC', 'PFNGLINDEXFORMATNVPROC',
'PFNGLTEXCOORDFORMATNVPROC', 'PFNGLEDGEFLAGFORMATNVPROC',
'PFNGLSECONDARYCOLORFORMATNVPROC', 'PFNGLFOGCOORDFORMATNVPROC',
'PFNGLVERTEXATTRIBFORMATNVPROC', 'PFNGLVERTEXATTRIBIFORMATNVPROC',
'PFNGLGETINTEGERUI64I_VNVPROC', 'GL_NV_shader_buffer_load',
'glGetBufferParameterui64vNV', 'glGetIntegerui64vNV',
'glGetNamedBufferParameterui64vNV', 'glIsBufferResidentNV',
'glIsNamedBufferResidentNV', 'glMakeBufferNonResidentNV',
'glMakeBufferResidentNV', 'glMakeNamedBufferNonResidentNV',
'glMakeNamedBufferResidentNV', 'glUniformui64NV', 'glUniformui64vNV',
'glGetUniformui64vNV', 'glProgramUniformui64NV', 'glProgramUniformui64vNV',
'PFNGLGETBUFFERPARAMETERUI64VNVPROC', 'PFNGLGETINTEGERUI64VNVPROC',
'PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC', 'PFNGLISBUFFERRESIDENTNVPROC',
'PFNGLISNAMEDBUFFERRESIDENTNVPROC', 'PFNGLMAKEBUFFERNONRESIDENTNVPROC',
'PFNGLMAKEBUFFERRESIDENTNVPROC', 'PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC',
'PFNGLMAKENAMEDBUFFERRESIDENTNVPROC', 'PFNGLUNIFORMUI64NVPROC',
'PFNGLUNIFORMUI64VNVPROC', 'PFNGLGETUNIFORMUI64VNVPROC',
'PFNGLPROGRAMUNIFORMUI64NVPROC', 'PFNGLPROGRAMUNIFORMUI64VNVPROC']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://oss.sgi.com/projects/ogl-sample/ABI/glxext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
from ctypes import *
from pyglet.gl.lib import link_GLX as _link_function
from pyglet.gl.lib import c_ptrdiff_t
if not hasattr(ctypes, 'c_int64'):
# XXX TODO completely wrong, but at least can import.
# Can c_longlong still be used?
c_int64 = c_long
c_uint64 = c_ulong
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for http://www.opengl.org/registry/api/glxext.h
import pyglet.libs.x11.xlib
import pyglet.gl.glx
# H (/usr/include/GL/glx.h:26)
# ARB_get_proc_address (/usr/include/GL/glx.h:317)
# GLXEXT_LEGACY (/usr/include/GL/glx.h:334)
GLX_GLXEXT_VERSION = 32 # GL/glxext.h:53
# VERSION_1_3 (GL/glxext.h:55)
# VERSION_1_4 (GL/glxext.h:114)
# ARB_get_proc_address (GL/glxext.h:119)
# ARB_multisample (GL/glxext.h:122)
GLX_SAMPLE_BUFFERS_ARB = 100000 # GL/glxext.h:123
GLX_SAMPLES_ARB = 100001 # GL/glxext.h:124
# ARB_vertex_buffer_object (GL/glxext.h:127)
GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = 8341 # GL/glxext.h:128
# ARB_fbconfig_float (GL/glxext.h:131)
GLX_RGBA_FLOAT_TYPE_ARB = 8377 # GL/glxext.h:132
GLX_RGBA_FLOAT_BIT_ARB = 4 # GL/glxext.h:133
# ARB_framebuffer_sRGB (GL/glxext.h:136)
GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = 8370 # GL/glxext.h:137
# ARB_create_context (GL/glxext.h:140)
GLX_CONTEXT_DEBUG_BIT_ARB = 1 # GL/glxext.h:141
GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 2 # GL/glxext.h:142
GLX_CONTEXT_MAJOR_VERSION_ARB = 8337 # GL/glxext.h:143
GLX_CONTEXT_MINOR_VERSION_ARB = 8338 # GL/glxext.h:144
GLX_CONTEXT_FLAGS_ARB = 8340 # GL/glxext.h:145
# ARB_create_context_profile (GL/glxext.h:148)
GLX_CONTEXT_CORE_PROFILE_BIT_ARB = 1 # GL/glxext.h:149
GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 2 # GL/glxext.h:150
GLX_CONTEXT_PROFILE_MASK_ARB = 37158 # GL/glxext.h:151
# ARB_create_context_robustness (GL/glxext.h:154)
GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = 4 # GL/glxext.h:155
GLX_LOSE_CONTEXT_ON_RESET_ARB = 33362 # GL/glxext.h:156
GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = 33366 # GL/glxext.h:157
GLX_NO_RESET_NOTIFICATION_ARB = 33377 # GL/glxext.h:158
# SGIS_multisample (GL/glxext.h:161)
GLX_SAMPLE_BUFFERS_SGIS = 100000 # GL/glxext.h:162
GLX_SAMPLES_SGIS = 100001 # GL/glxext.h:163
# EXT_visual_info (GL/glxext.h:166)
GLX_X_VISUAL_TYPE_EXT = 34 # GL/glxext.h:167
GLX_TRANSPARENT_TYPE_EXT = 35 # GL/glxext.h:168
GLX_TRANSPARENT_INDEX_VALUE_EXT = 36 # GL/glxext.h:169
GLX_TRANSPARENT_RED_VALUE_EXT = 37 # GL/glxext.h:170
GLX_TRANSPARENT_GREEN_VALUE_EXT = 38 # GL/glxext.h:171
GLX_TRANSPARENT_BLUE_VALUE_EXT = 39 # GL/glxext.h:172
GLX_TRANSPARENT_ALPHA_VALUE_EXT = 40 # GL/glxext.h:173
GLX_NONE_EXT = 32768 # GL/glxext.h:174
GLX_TRUE_COLOR_EXT = 32770 # GL/glxext.h:175
GLX_DIRECT_COLOR_EXT = 32771 # GL/glxext.h:176
GLX_PSEUDO_COLOR_EXT = 32772 # GL/glxext.h:177
GLX_STATIC_COLOR_EXT = 32773 # GL/glxext.h:178
GLX_GRAY_SCALE_EXT = 32774 # GL/glxext.h:179
GLX_STATIC_GRAY_EXT = 32775 # GL/glxext.h:180
GLX_TRANSPARENT_RGB_EXT = 32776 # GL/glxext.h:181
GLX_TRANSPARENT_INDEX_EXT = 32777 # GL/glxext.h:182
# SGI_swap_control (GL/glxext.h:185)
# SGI_video_sync (GL/glxext.h:188)
# SGI_make_current_read (GL/glxext.h:191)
# SGIX_video_source (GL/glxext.h:194)
# EXT_visual_rating (GL/glxext.h:197)
GLX_VISUAL_CAVEAT_EXT = 32 # GL/glxext.h:198
GLX_SLOW_VISUAL_EXT = 32769 # GL/glxext.h:199
GLX_NON_CONFORMANT_VISUAL_EXT = 32781 # GL/glxext.h:200
# EXT_import_context (GL/glxext.h:204)
GLX_SHARE_CONTEXT_EXT = 32778 # GL/glxext.h:205
GLX_VISUAL_ID_EXT = 32779 # GL/glxext.h:206
GLX_SCREEN_EXT = 32780 # GL/glxext.h:207
# SGIX_fbconfig (GL/glxext.h:210)
GLX_WINDOW_BIT_SGIX = 1 # GL/glxext.h:211
GLX_PIXMAP_BIT_SGIX = 2 # GL/glxext.h:212
GLX_RGBA_BIT_SGIX = 1 # GL/glxext.h:213
GLX_COLOR_INDEX_BIT_SGIX = 2 # GL/glxext.h:214
GLX_DRAWABLE_TYPE_SGIX = 32784 # GL/glxext.h:215
GLX_RENDER_TYPE_SGIX = 32785 # GL/glxext.h:216
GLX_X_RENDERABLE_SGIX = 32786 # GL/glxext.h:217
GLX_FBCONFIG_ID_SGIX = 32787 # GL/glxext.h:218
GLX_RGBA_TYPE_SGIX = 32788 # GL/glxext.h:219
GLX_COLOR_INDEX_TYPE_SGIX = 32789 # GL/glxext.h:220
# SGIX_pbuffer (GL/glxext.h:224)
GLX_PBUFFER_BIT_SGIX = 4 # GL/glxext.h:225
GLX_BUFFER_CLOBBER_MASK_SGIX = 134217728 # GL/glxext.h:226
GLX_FRONT_LEFT_BUFFER_BIT_SGIX = 1 # GL/glxext.h:227
GLX_FRONT_RIGHT_BUFFER_BIT_SGIX = 2 # GL/glxext.h:228
GLX_BACK_LEFT_BUFFER_BIT_SGIX = 4 # GL/glxext.h:229
GLX_BACK_RIGHT_BUFFER_BIT_SGIX = 8 # GL/glxext.h:230
GLX_AUX_BUFFERS_BIT_SGIX = 16 # GL/glxext.h:231
GLX_DEPTH_BUFFER_BIT_SGIX = 32 # GL/glxext.h:232
GLX_STENCIL_BUFFER_BIT_SGIX = 64 # GL/glxext.h:233
GLX_ACCUM_BUFFER_BIT_SGIX = 128 # GL/glxext.h:234
GLX_SAMPLE_BUFFERS_BIT_SGIX = 256 # GL/glxext.h:235
GLX_MAX_PBUFFER_WIDTH_SGIX = 32790 # GL/glxext.h:236
GLX_MAX_PBUFFER_HEIGHT_SGIX = 32791 # GL/glxext.h:237
GLX_MAX_PBUFFER_PIXELS_SGIX = 32792 # GL/glxext.h:238
GLX_OPTIMAL_PBUFFER_WIDTH_SGIX = 32793 # GL/glxext.h:239
GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX = 32794 # GL/glxext.h:240
GLX_PRESERVED_CONTENTS_SGIX = 32795 # GL/glxext.h:241
GLX_LARGEST_PBUFFER_SGIX = 32796 # GL/glxext.h:242
GLX_WIDTH_SGIX = 32797 # GL/glxext.h:243
GLX_HEIGHT_SGIX = 32798 # GL/glxext.h:244
GLX_EVENT_MASK_SGIX = 32799 # GL/glxext.h:245
GLX_DAMAGED_SGIX = 32800 # GL/glxext.h:246
GLX_SAVED_SGIX = 32801 # GL/glxext.h:247
GLX_WINDOW_SGIX = 32802 # GL/glxext.h:248
GLX_PBUFFER_SGIX = 32803 # GL/glxext.h:249
# SGI_cushion (GL/glxext.h:252)
# SGIX_video_resize (GL/glxext.h:255)
GLX_SYNC_FRAME_SGIX = 0 # GL/glxext.h:256
GLX_SYNC_SWAP_SGIX = 1 # GL/glxext.h:257
# SGIX_dmbuffer (GL/glxext.h:260)
GLX_DIGITAL_MEDIA_PBUFFER_SGIX = 32804 # GL/glxext.h:261
# SGIX_swap_group (GL/glxext.h:264)
# SGIX_swap_barrier (GL/glxext.h:267)
# SGIS_blended_overlay (GL/glxext.h:270)
GLX_BLENDED_RGBA_SGIS = 32805 # GL/glxext.h:271
# SGIS_shared_multisample (GL/glxext.h:274)
GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS = 32806 # GL/glxext.h:275
GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS = 32807 # GL/glxext.h:276
# SUN_get_transparent_index (GL/glxext.h:279)
# 3DFX_multisample (GL/glxext.h:282)
GLX_SAMPLE_BUFFERS_3DFX = 32848 # GL/glxext.h:283
GLX_SAMPLES_3DFX = 32849 # GL/glxext.h:284
# MESA_copy_sub_buffer (GL/glxext.h:287)
# MESA_pixmap_colormap (GL/glxext.h:290)
# MESA_release_buffers (GL/glxext.h:293)
# MESA_set_3dfx_mode (GL/glxext.h:296)
GLX_3DFX_WINDOW_MODE_MESA = 1 # GL/glxext.h:297
GLX_3DFX_FULLSCREEN_MODE_MESA = 2 # GL/glxext.h:298
# SGIX_visual_select_group (GL/glxext.h:301)
GLX_VISUAL_SELECT_GROUP_SGIX = 32808 # GL/glxext.h:302
# OML_swap_method (GL/glxext.h:305)
GLX_SWAP_METHOD_OML = 32864 # GL/glxext.h:306
GLX_SWAP_EXCHANGE_OML = 32865 # GL/glxext.h:307
GLX_SWAP_COPY_OML = 32866 # GL/glxext.h:308
GLX_SWAP_UNDEFINED_OML = 32867 # GL/glxext.h:309
# OML_sync_control (GL/glxext.h:312)
# NV_float_buffer (GL/glxext.h:315)
GLX_FLOAT_COMPONENTS_NV = 8368 # GL/glxext.h:316
# SGIX_hyperpipe (GL/glxext.h:319)
GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX = 80 # GL/glxext.h:320
GLX_BAD_HYPERPIPE_CONFIG_SGIX = 91 # GL/glxext.h:321
GLX_BAD_HYPERPIPE_SGIX = 92 # GL/glxext.h:322
GLX_HYPERPIPE_DISPLAY_PIPE_SGIX = 1 # GL/glxext.h:323
GLX_HYPERPIPE_RENDER_PIPE_SGIX = 2 # GL/glxext.h:324
GLX_PIPE_RECT_SGIX = 1 # GL/glxext.h:325
GLX_PIPE_RECT_LIMITS_SGIX = 2 # GL/glxext.h:326
GLX_HYPERPIPE_STEREO_SGIX = 3 # GL/glxext.h:327
GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX = 4 # GL/glxext.h:328
GLX_HYPERPIPE_ID_SGIX = 32816 # GL/glxext.h:329
# MESA_agp_offset (GL/glxext.h:332)
# EXT_fbconfig_packed_float (GL/glxext.h:335)
GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = 8369 # GL/glxext.h:336
GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = 8 # GL/glxext.h:337
# EXT_framebuffer_sRGB (GL/glxext.h:340)
GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = 8370 # GL/glxext.h:341
# EXT_texture_from_pixmap (GL/glxext.h:344)
GLX_TEXTURE_1D_BIT_EXT = 1 # GL/glxext.h:345
GLX_TEXTURE_2D_BIT_EXT = 2 # GL/glxext.h:346
GLX_TEXTURE_RECTANGLE_BIT_EXT = 4 # GL/glxext.h:347
GLX_BIND_TO_TEXTURE_RGB_EXT = 8400 # GL/glxext.h:348
GLX_BIND_TO_TEXTURE_RGBA_EXT = 8401 # GL/glxext.h:349
GLX_BIND_TO_MIPMAP_TEXTURE_EXT = 8402 # GL/glxext.h:350
GLX_BIND_TO_TEXTURE_TARGETS_EXT = 8403 # GL/glxext.h:351
GLX_Y_INVERTED_EXT = 8404 # GL/glxext.h:352
GLX_TEXTURE_FORMAT_EXT = 8405 # GL/glxext.h:353
GLX_TEXTURE_TARGET_EXT = 8406 # GL/glxext.h:354
GLX_MIPMAP_TEXTURE_EXT = 8407 # GL/glxext.h:355
GLX_TEXTURE_FORMAT_NONE_EXT = 8408 # GL/glxext.h:356
GLX_TEXTURE_FORMAT_RGB_EXT = 8409 # GL/glxext.h:357
GLX_TEXTURE_FORMAT_RGBA_EXT = 8410 # GL/glxext.h:358
GLX_TEXTURE_1D_EXT = 8411 # GL/glxext.h:359
GLX_TEXTURE_2D_EXT = 8412 # GL/glxext.h:360
GLX_TEXTURE_RECTANGLE_EXT = 8413 # GL/glxext.h:361
GLX_FRONT_LEFT_EXT = 8414 # GL/glxext.h:362
GLX_FRONT_RIGHT_EXT = 8415 # GL/glxext.h:363
GLX_BACK_LEFT_EXT = 8416 # GL/glxext.h:364
GLX_BACK_RIGHT_EXT = 8417 # GL/glxext.h:365
GLX_FRONT_EXT = 8414 # GL/glxext.h:366
GLX_BACK_EXT = 8416 # GL/glxext.h:367
GLX_AUX0_EXT = 8418 # GL/glxext.h:368
GLX_AUX1_EXT = 8419 # GL/glxext.h:369
GLX_AUX2_EXT = 8420 # GL/glxext.h:370
GLX_AUX3_EXT = 8421 # GL/glxext.h:371
GLX_AUX4_EXT = 8422 # GL/glxext.h:372
GLX_AUX5_EXT = 8423 # GL/glxext.h:373
GLX_AUX6_EXT = 8424 # GL/glxext.h:374
GLX_AUX7_EXT = 8425 # GL/glxext.h:375
GLX_AUX8_EXT = 8426 # GL/glxext.h:376
GLX_AUX9_EXT = 8427 # GL/glxext.h:377
# NV_present_video (GL/glxext.h:380)
GLX_NUM_VIDEO_SLOTS_NV = 8432 # GL/glxext.h:381
# NV_video_out (GL/glxext.h:384)
GLX_VIDEO_OUT_COLOR_NV = 8387 # GL/glxext.h:385
GLX_VIDEO_OUT_ALPHA_NV = 8388 # GL/glxext.h:386
GLX_VIDEO_OUT_DEPTH_NV = 8389 # GL/glxext.h:387
GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV = 8390 # GL/glxext.h:388
GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV = 8391 # GL/glxext.h:389
GLX_VIDEO_OUT_FRAME_NV = 8392 # GL/glxext.h:390
GLX_VIDEO_OUT_FIELD_1_NV = 8393 # GL/glxext.h:391
GLX_VIDEO_OUT_FIELD_2_NV = 8394 # GL/glxext.h:392
GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV = 8395 # GL/glxext.h:393
GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV = 8396 # GL/glxext.h:394
# NV_swap_group (GL/glxext.h:397)
# NV_video_capture (GL/glxext.h:400)
GLX_DEVICE_ID_NV = 8397 # GL/glxext.h:401
GLX_UNIQUE_ID_NV = 8398 # GL/glxext.h:402
GLX_NUM_VIDEO_CAPTURE_SLOTS_NV = 8399 # GL/glxext.h:403
# EXT_swap_control (GL/glxext.h:406)
GLX_SWAP_INTERVAL_EXT = 8433 # GL/glxext.h:407
GLX_MAX_SWAP_INTERVAL_EXT = 8434 # GL/glxext.h:408
# NV_copy_image (GL/glxext.h:411)
# INTEL_swap_event (GL/glxext.h:414)
GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK = 67108864 # GL/glxext.h:415
GLX_EXCHANGE_COMPLETE_INTEL = 33152 # GL/glxext.h:416
GLX_COPY_COMPLETE_INTEL = 33153 # GL/glxext.h:417
GLX_FLIP_COMPLETE_INTEL = 33154 # GL/glxext.h:418
# NV_multisample_coverage (GL/glxext.h:421)
GLX_COVERAGE_SAMPLES_NV = 100001 # GL/glxext.h:422
GLX_COLOR_SAMPLES_NV = 8371 # GL/glxext.h:423
# AMD_gpu_association (GL/glxext.h:426)
GLX_GPU_VENDOR_AMD = 7936 # GL/glxext.h:427
GLX_GPU_RENDERER_STRING_AMD = 7937 # GL/glxext.h:428
GLX_GPU_OPENGL_VERSION_STRING_AMD = 7938 # GL/glxext.h:429
GLX_GPU_FASTEST_TARGET_GPUS_AMD = 8610 # GL/glxext.h:430
GLX_GPU_RAM_AMD = 8611 # GL/glxext.h:431
GLX_GPU_CLOCK_AMD = 8612 # GL/glxext.h:432
GLX_GPU_NUM_PIPES_AMD = 8613 # GL/glxext.h:433
GLX_GPU_NUM_SIMD_AMD = 8614 # GL/glxext.h:434
GLX_GPU_NUM_RB_AMD = 8615 # GL/glxext.h:435
GLX_GPU_NUM_SPI_AMD = 8616 # GL/glxext.h:436
# EXT_create_context_es2_profile (GL/glxext.h:439)
GLX_CONTEXT_ES2_PROFILE_BIT_EXT = 4 # GL/glxext.h:440
# ARB_get_proc_address (GL/glxext.h:446)
# SGIX_video_source (GL/glxext.h:450)
XID = pyglet.libs.x11.xlib.XID
GLXVideoSourceSGIX = XID # GL/glxext.h:451
# SGIX_fbconfig (GL/glxext.h:454)
GLXFBConfigIDSGIX = XID # GL/glxext.h:455
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
GLXFBConfigSGIX = POINTER(struct___GLXFBConfigRec) # GL/glxext.h:456
# SGIX_pbuffer (GL/glxext.h:459)
GLXPbufferSGIX = XID # GL/glxext.h:460
class struct_anon_106(Structure):
__slots__ = [
'type',
'serial',
'send_event',
'display',
'drawable',
'event_type',
'draw_type',
'mask',
'x',
'y',
'width',
'height',
'count',
]
Display = pyglet.libs.x11.xlib.Display
GLXDrawable = pyglet.gl.glx.GLXDrawable
struct_anon_106._fields_ = [
('type', c_int),
('serial', c_ulong),
('send_event', c_int),
('display', POINTER(Display)),
('drawable', GLXDrawable),
('event_type', c_int),
('draw_type', c_int),
('mask', c_uint),
('x', c_int),
('y', c_int),
('width', c_int),
('height', c_int),
('count', c_int),
]
GLXBufferClobberEventSGIX = struct_anon_106 # GL/glxext.h:473
# NV_video_output (GL/glxext.h:476)
GLXVideoDeviceNV = c_uint # GL/glxext.h:477
# NV_video_capture (GL/glxext.h:480)
GLXVideoCaptureDeviceNV = XID # GL/glxext.h:481
# VERSION_1_3 (GL/glxext.h:521)
# VERSION_1_4 (GL/glxext.h:563)
# ARB_get_proc_address (GL/glxext.h:571)
# ARB_multisample (GL/glxext.h:579)
GLX_ARB_multisample = 1 # GL/glxext.h:580
# ARB_fbconfig_float (GL/glxext.h:583)
GLX_ARB_fbconfig_float = 1 # GL/glxext.h:584
# ARB_framebuffer_sRGB (GL/glxext.h:587)
GLX_ARB_framebuffer_sRGB = 1 # GL/glxext.h:588
# ARB_create_context (GL/glxext.h:591)
GLX_ARB_create_context = 1 # GL/glxext.h:592
GLXContext = pyglet.gl.glx.GLXContext
GLXFBConfig = pyglet.gl.glx.GLXFBConfig
# GL/glxext.h:594
glXCreateContextAttribsARB = _link_function('glXCreateContextAttribsARB', GLXContext, [POINTER(Display), GLXFBConfig, GLXContext, c_int, POINTER(c_int)], 'ARB_create_context')
PFNGLXCREATECONTEXTATTRIBSARBPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXFBConfig, GLXContext, c_int, POINTER(c_int)) # GL/glxext.h:596
# ARB_create_context_profile (GL/glxext.h:599)
GLX_ARB_create_context_profile = 1 # GL/glxext.h:600
# ARB_create_context_robustness (GL/glxext.h:603)
GLX_ARB_create_context_robustness = 1 # GL/glxext.h:604
# SGIS_multisample (GL/glxext.h:607)
GLX_SGIS_multisample = 1 # GL/glxext.h:608
# EXT_visual_info (GL/glxext.h:611)
GLX_EXT_visual_info = 1 # GL/glxext.h:612
# SGI_swap_control (GL/glxext.h:615)
GLX_SGI_swap_control = 1 # GL/glxext.h:616
# GL/glxext.h:618
glXSwapIntervalSGI = _link_function('glXSwapIntervalSGI', c_int, [c_int], 'SGI_swap_control')
PFNGLXSWAPINTERVALSGIPROC = CFUNCTYPE(c_int, c_int) # GL/glxext.h:620
# SGI_video_sync (GL/glxext.h:623)
GLX_SGI_video_sync = 1 # GL/glxext.h:624
# GL/glxext.h:626
glXGetVideoSyncSGI = _link_function('glXGetVideoSyncSGI', c_int, [POINTER(c_uint)], 'SGI_video_sync')
# GL/glxext.h:627
glXWaitVideoSyncSGI = _link_function('glXWaitVideoSyncSGI', c_int, [c_int, c_int, POINTER(c_uint)], 'SGI_video_sync')
PFNGLXGETVIDEOSYNCSGIPROC = CFUNCTYPE(c_int, POINTER(c_uint)) # GL/glxext.h:629
PFNGLXWAITVIDEOSYNCSGIPROC = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_uint)) # GL/glxext.h:630
# SGI_make_current_read (GL/glxext.h:633)
GLX_SGI_make_current_read = 1 # GL/glxext.h:634
# GL/glxext.h:636
glXMakeCurrentReadSGI = _link_function('glXMakeCurrentReadSGI', c_int, [POINTER(Display), GLXDrawable, GLXDrawable, GLXContext], 'SGI_make_current_read')
# GL/glxext.h:637
glXGetCurrentReadDrawableSGI = _link_function('glXGetCurrentReadDrawableSGI', GLXDrawable, [], 'SGI_make_current_read')
PFNGLXMAKECURRENTREADSGIPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, GLXDrawable, GLXContext) # GL/glxext.h:639
PFNGLXGETCURRENTREADDRAWABLESGIPROC = CFUNCTYPE(GLXDrawable) # GL/glxext.h:640
# SGIX_video_source (GL/glxext.h:643)
GLX_SGIX_video_source = 1 # GL/glxext.h:644
# EXT_visual_rating (GL/glxext.h:655)
GLX_EXT_visual_rating = 1 # GL/glxext.h:656
# EXT_import_context (GL/glxext.h:659)
GLX_EXT_import_context = 1 # GL/glxext.h:660
# GL/glxext.h:662
glXGetCurrentDisplayEXT = _link_function('glXGetCurrentDisplayEXT', POINTER(Display), [], 'EXT_import_context')
# GL/glxext.h:663
glXQueryContextInfoEXT = _link_function('glXQueryContextInfoEXT', c_int, [POINTER(Display), GLXContext, c_int, POINTER(c_int)], 'EXT_import_context')
GLXContextID = pyglet.gl.glx.GLXContextID
# GL/glxext.h:664
glXGetContextIDEXT = _link_function('glXGetContextIDEXT', GLXContextID, [GLXContext], 'EXT_import_context')
# GL/glxext.h:665
glXImportContextEXT = _link_function('glXImportContextEXT', GLXContext, [POINTER(Display), GLXContextID], 'EXT_import_context')
# GL/glxext.h:666
glXFreeContextEXT = _link_function('glXFreeContextEXT', None, [POINTER(Display), GLXContext], 'EXT_import_context')
PFNGLXGETCURRENTDISPLAYEXTPROC = CFUNCTYPE(POINTER(Display)) # GL/glxext.h:668
PFNGLXQUERYCONTEXTINFOEXTPROC = CFUNCTYPE(c_int, POINTER(Display), GLXContext, c_int, POINTER(c_int)) # GL/glxext.h:669
PFNGLXGETCONTEXTIDEXTPROC = CFUNCTYPE(GLXContextID, GLXContext) # GL/glxext.h:670
PFNGLXIMPORTCONTEXTEXTPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXContextID) # GL/glxext.h:671
PFNGLXFREECONTEXTEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXContext) # GL/glxext.h:672
# SGIX_fbconfig (GL/glxext.h:675)
GLX_SGIX_fbconfig = 1 # GL/glxext.h:676
# GL/glxext.h:678
glXGetFBConfigAttribSGIX = _link_function('glXGetFBConfigAttribSGIX', c_int, [POINTER(Display), GLXFBConfigSGIX, c_int, POINTER(c_int)], 'SGIX_fbconfig')
# GL/glxext.h:679
glXChooseFBConfigSGIX = _link_function('glXChooseFBConfigSGIX', POINTER(GLXFBConfigSGIX), [POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)], 'SGIX_fbconfig')
GLXPixmap = pyglet.gl.glx.GLXPixmap
Pixmap = pyglet.libs.x11.xlib.Pixmap
# GL/glxext.h:680
glXCreateGLXPixmapWithConfigSGIX = _link_function('glXCreateGLXPixmapWithConfigSGIX', GLXPixmap, [POINTER(Display), GLXFBConfigSGIX, Pixmap], 'SGIX_fbconfig')
# GL/glxext.h:681
glXCreateContextWithConfigSGIX = _link_function('glXCreateContextWithConfigSGIX', GLXContext, [POINTER(Display), GLXFBConfigSGIX, c_int, GLXContext, c_int], 'SGIX_fbconfig')
XVisualInfo = pyglet.libs.x11.xlib.XVisualInfo
# GL/glxext.h:682
glXGetVisualFromFBConfigSGIX = _link_function('glXGetVisualFromFBConfigSGIX', POINTER(XVisualInfo), [POINTER(Display), GLXFBConfigSGIX], 'SGIX_fbconfig')
# GL/glxext.h:683
glXGetFBConfigFromVisualSGIX = _link_function('glXGetFBConfigFromVisualSGIX', GLXFBConfigSGIX, [POINTER(Display), POINTER(XVisualInfo)], 'SGIX_fbconfig')
PFNGLXGETFBCONFIGATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), GLXFBConfigSGIX, c_int, POINTER(c_int)) # GL/glxext.h:685
PFNGLXCHOOSEFBCONFIGSGIXPROC = CFUNCTYPE(POINTER(GLXFBConfigSGIX), POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)) # GL/glxext.h:686
PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC = CFUNCTYPE(GLXPixmap, POINTER(Display), GLXFBConfigSGIX, Pixmap) # GL/glxext.h:687
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXFBConfigSGIX, c_int, GLXContext, c_int) # GL/glxext.h:688
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC = CFUNCTYPE(POINTER(XVisualInfo), POINTER(Display), GLXFBConfigSGIX) # GL/glxext.h:689
PFNGLXGETFBCONFIGFROMVISUALSGIXPROC = CFUNCTYPE(GLXFBConfigSGIX, POINTER(Display), POINTER(XVisualInfo)) # GL/glxext.h:690
# SGIX_pbuffer (GL/glxext.h:693)
GLX_SGIX_pbuffer = 1 # GL/glxext.h:694
# GL/glxext.h:696
glXCreateGLXPbufferSGIX = _link_function('glXCreateGLXPbufferSGIX', GLXPbufferSGIX, [POINTER(Display), GLXFBConfigSGIX, c_uint, c_uint, POINTER(c_int)], 'SGIX_pbuffer')
# GL/glxext.h:697
glXDestroyGLXPbufferSGIX = _link_function('glXDestroyGLXPbufferSGIX', None, [POINTER(Display), GLXPbufferSGIX], 'SGIX_pbuffer')
# GL/glxext.h:698
glXQueryGLXPbufferSGIX = _link_function('glXQueryGLXPbufferSGIX', c_int, [POINTER(Display), GLXPbufferSGIX, c_int, POINTER(c_uint)], 'SGIX_pbuffer')
# GL/glxext.h:699
glXSelectEventSGIX = _link_function('glXSelectEventSGIX', None, [POINTER(Display), GLXDrawable, c_ulong], 'SGIX_pbuffer')
# GL/glxext.h:700
glXGetSelectedEventSGIX = _link_function('glXGetSelectedEventSGIX', None, [POINTER(Display), GLXDrawable, POINTER(c_ulong)], 'SGIX_pbuffer')
PFNGLXCREATEGLXPBUFFERSGIXPROC = CFUNCTYPE(GLXPbufferSGIX, POINTER(Display), GLXFBConfigSGIX, c_uint, c_uint, POINTER(c_int)) # GL/glxext.h:702
PFNGLXDESTROYGLXPBUFFERSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXPbufferSGIX) # GL/glxext.h:703
PFNGLXQUERYGLXPBUFFERSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbufferSGIX, c_int, POINTER(c_uint)) # GL/glxext.h:704
PFNGLXSELECTEVENTSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_ulong) # GL/glxext.h:705
PFNGLXGETSELECTEDEVENTSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, POINTER(c_ulong)) # GL/glxext.h:706
# SGI_cushion (GL/glxext.h:709)
GLX_SGI_cushion = 1 # GL/glxext.h:710
Window = pyglet.libs.x11.xlib.Window
# GL/glxext.h:712
glXCushionSGI = _link_function('glXCushionSGI', None, [POINTER(Display), Window, c_float], 'SGI_cushion')
PFNGLXCUSHIONSGIPROC = CFUNCTYPE(None, POINTER(Display), Window, c_float) # GL/glxext.h:714
# SGIX_video_resize (GL/glxext.h:717)
GLX_SGIX_video_resize = 1 # GL/glxext.h:718
# GL/glxext.h:720
glXBindChannelToWindowSGIX = _link_function('glXBindChannelToWindowSGIX', c_int, [POINTER(Display), c_int, c_int, Window], 'SGIX_video_resize')
# GL/glxext.h:721
glXChannelRectSGIX = _link_function('glXChannelRectSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, c_int, c_int, c_int], 'SGIX_video_resize')
# GL/glxext.h:722
glXQueryChannelRectSGIX = _link_function('glXQueryChannelRectSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], 'SGIX_video_resize')
# GL/glxext.h:723
glXQueryChannelDeltasSGIX = _link_function('glXQueryChannelDeltasSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)], 'SGIX_video_resize')
GLenum = c_uint # /usr/include/GL/gl.h:153
# GL/glxext.h:724
glXChannelRectSyncSGIX = _link_function('glXChannelRectSyncSGIX', c_int, [POINTER(Display), c_int, c_int, GLenum], 'SGIX_video_resize')
PFNGLXBINDCHANNELTOWINDOWSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, Window) # GL/glxext.h:726
PFNGLXCHANNELRECTSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, c_int, c_int, c_int) # GL/glxext.h:727
PFNGLXQUERYCHANNELRECTSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)) # GL/glxext.h:728
PFNGLXQUERYCHANNELDELTASSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)) # GL/glxext.h:729
PFNGLXCHANNELRECTSYNCSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, GLenum) # GL/glxext.h:730
# SGIX_dmbuffer (GL/glxext.h:733)
GLX_SGIX_dmbuffer = 1 # GL/glxext.h:734
# SGIX_swap_group (GL/glxext.h:743)
GLX_SGIX_swap_group = 1 # GL/glxext.h:744
# GL/glxext.h:746
glXJoinSwapGroupSGIX = _link_function('glXJoinSwapGroupSGIX', None, [POINTER(Display), GLXDrawable, GLXDrawable], 'SGIX_swap_group')
PFNGLXJOINSWAPGROUPSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, GLXDrawable) # GL/glxext.h:748
# SGIX_swap_barrier (GL/glxext.h:751)
GLX_SGIX_swap_barrier = 1 # GL/glxext.h:752
# GL/glxext.h:754
glXBindSwapBarrierSGIX = _link_function('glXBindSwapBarrierSGIX', None, [POINTER(Display), GLXDrawable, c_int], 'SGIX_swap_barrier')
# GL/glxext.h:755
glXQueryMaxSwapBarriersSGIX = _link_function('glXQueryMaxSwapBarriersSGIX', c_int, [POINTER(Display), c_int, POINTER(c_int)], 'SGIX_swap_barrier')
PFNGLXBINDSWAPBARRIERSGIXPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int) # GL/glxext.h:757
PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:758
# SUN_get_transparent_index (GL/glxext.h:761)
GLX_SUN_get_transparent_index = 1 # GL/glxext.h:762
# GL/glxext.h:764
glXGetTransparentIndexSUN = _link_function('glXGetTransparentIndexSUN', c_int, [POINTER(Display), Window, Window, POINTER(c_long)], 'SUN_get_transparent_index')
PFNGLXGETTRANSPARENTINDEXSUNPROC = CFUNCTYPE(c_int, POINTER(Display), Window, Window, POINTER(c_long)) # GL/glxext.h:766
# MESA_copy_sub_buffer (GL/glxext.h:769)
GLX_MESA_copy_sub_buffer = 1 # GL/glxext.h:770
# GL/glxext.h:772
glXCopySubBufferMESA = _link_function('glXCopySubBufferMESA', None, [POINTER(Display), GLXDrawable, c_int, c_int, c_int, c_int], 'MESA_copy_sub_buffer')
PFNGLXCOPYSUBBUFFERMESAPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int, c_int, c_int, c_int) # GL/glxext.h:774
# MESA_pixmap_colormap (GL/glxext.h:777)
GLX_MESA_pixmap_colormap = 1 # GL/glxext.h:778
Colormap = pyglet.libs.x11.xlib.Colormap
# GL/glxext.h:780
glXCreateGLXPixmapMESA = _link_function('glXCreateGLXPixmapMESA', GLXPixmap, [POINTER(Display), POINTER(XVisualInfo), Pixmap, Colormap], 'MESA_pixmap_colormap')
PFNGLXCREATEGLXPIXMAPMESAPROC = CFUNCTYPE(GLXPixmap, POINTER(Display), POINTER(XVisualInfo), Pixmap, Colormap) # GL/glxext.h:782
# MESA_release_buffers (GL/glxext.h:785)
GLX_MESA_release_buffers = 1 # GL/glxext.h:786
# GL/glxext.h:788
glXReleaseBuffersMESA = _link_function('glXReleaseBuffersMESA', c_int, [POINTER(Display), GLXDrawable], 'MESA_release_buffers')
PFNGLXRELEASEBUFFERSMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable) # GL/glxext.h:790
# MESA_set_3dfx_mode (GL/glxext.h:793)
GLX_MESA_set_3dfx_mode = 1 # GL/glxext.h:794
# GL/glxext.h:796
glXSet3DfxModeMESA = _link_function('glXSet3DfxModeMESA', c_int, [c_int], 'MESA_set_3dfx_mode')
PFNGLXSET3DFXMODEMESAPROC = CFUNCTYPE(c_int, c_int) # GL/glxext.h:798
# SGIX_visual_select_group (GL/glxext.h:801)
GLX_SGIX_visual_select_group = 1 # GL/glxext.h:802
# OML_swap_method (GL/glxext.h:805)
GLX_OML_swap_method = 1 # GL/glxext.h:806
# OML_sync_control (GL/glxext.h:809)
GLX_OML_sync_control = 1 # GL/glxext.h:810
# GL/glxext.h:812
glXGetSyncValuesOML = _link_function('glXGetSyncValuesOML', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
# GL/glxext.h:813
glXGetMscRateOML = _link_function('glXGetMscRateOML', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int32), POINTER(c_int32)], 'OML_sync_control')
# GL/glxext.h:814
glXSwapBuffersMscOML = _link_function('glXSwapBuffersMscOML', c_int64, [POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64], 'OML_sync_control')
# GL/glxext.h:815
glXWaitForMscOML = _link_function('glXWaitForMscOML', c_int, [POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
# GL/glxext.h:816
glXWaitForSbcOML = _link_function('glXWaitForSbcOML', c_int, [POINTER(Display), GLXDrawable, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)], 'OML_sync_control')
PFNGLXGETSYNCVALUESOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:818
PFNGLXGETMSCRATEOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_int32), POINTER(c_int32)) # GL/glxext.h:819
PFNGLXSWAPBUFFERSMSCOMLPROC = CFUNCTYPE(c_int64, POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64) # GL/glxext.h:820
PFNGLXWAITFORMSCOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, c_int64, c_int64, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:821
PFNGLXWAITFORSBCOMLPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, c_int64, POINTER(c_int64), POINTER(c_int64), POINTER(c_int64)) # GL/glxext.h:822
# NV_float_buffer (GL/glxext.h:825)
GLX_NV_float_buffer = 1 # GL/glxext.h:826
# SGIX_hyperpipe (GL/glxext.h:829)
GLX_SGIX_hyperpipe = 1 # GL/glxext.h:830
class struct_anon_107(Structure):
__slots__ = [
'pipeName',
'networkId',
]
struct_anon_107._fields_ = [
('pipeName', c_char * 80),
('networkId', c_int),
]
GLXHyperpipeNetworkSGIX = struct_anon_107 # GL/glxext.h:835
class struct_anon_108(Structure):
__slots__ = [
'pipeName',
'channel',
'participationType',
'timeSlice',
]
struct_anon_108._fields_ = [
('pipeName', c_char * 80),
('channel', c_int),
('participationType', c_uint),
('timeSlice', c_int),
]
GLXHyperpipeConfigSGIX = struct_anon_108 # GL/glxext.h:843
class struct_anon_109(Structure):
__slots__ = [
'pipeName',
'srcXOrigin',
'srcYOrigin',
'srcWidth',
'srcHeight',
'destXOrigin',
'destYOrigin',
'destWidth',
'destHeight',
]
struct_anon_109._fields_ = [
('pipeName', c_char * 80),
('srcXOrigin', c_int),
('srcYOrigin', c_int),
('srcWidth', c_int),
('srcHeight', c_int),
('destXOrigin', c_int),
('destYOrigin', c_int),
('destWidth', c_int),
('destHeight', c_int),
]
GLXPipeRect = struct_anon_109 # GL/glxext.h:849
class struct_anon_110(Structure):
__slots__ = [
'pipeName',
'XOrigin',
'YOrigin',
'maxHeight',
'maxWidth',
]
struct_anon_110._fields_ = [
('pipeName', c_char * 80),
('XOrigin', c_int),
('YOrigin', c_int),
('maxHeight', c_int),
('maxWidth', c_int),
]
GLXPipeRectLimits = struct_anon_110 # GL/glxext.h:854
# GL/glxext.h:857
glXQueryHyperpipeNetworkSGIX = _link_function('glXQueryHyperpipeNetworkSGIX', POINTER(GLXHyperpipeNetworkSGIX), [POINTER(Display), POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:858
glXHyperpipeConfigSGIX = _link_function('glXHyperpipeConfigSGIX', c_int, [POINTER(Display), c_int, c_int, POINTER(GLXHyperpipeConfigSGIX), POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:859
glXQueryHyperpipeConfigSGIX = _link_function('glXQueryHyperpipeConfigSGIX', POINTER(GLXHyperpipeConfigSGIX), [POINTER(Display), c_int, POINTER(c_int)], 'SGIX_hyperpipe')
# GL/glxext.h:860
glXDestroyHyperpipeConfigSGIX = _link_function('glXDestroyHyperpipeConfigSGIX', c_int, [POINTER(Display), c_int], 'SGIX_hyperpipe')
# GL/glxext.h:861
glXBindHyperpipeSGIX = _link_function('glXBindHyperpipeSGIX', c_int, [POINTER(Display), c_int], 'SGIX_hyperpipe')
# GL/glxext.h:862
glXQueryHyperpipeBestAttribSGIX = _link_function('glXQueryHyperpipeBestAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None), POINTER(None)], 'SGIX_hyperpipe')
# GL/glxext.h:863
glXHyperpipeAttribSGIX = _link_function('glXHyperpipeAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None)], 'SGIX_hyperpipe')
# GL/glxext.h:864
glXQueryHyperpipeAttribSGIX = _link_function('glXQueryHyperpipeAttribSGIX', c_int, [POINTER(Display), c_int, c_int, c_int, POINTER(None)], 'SGIX_hyperpipe')
PFNGLXQUERYHYPERPIPENETWORKSGIXPROC = CFUNCTYPE(POINTER(GLXHyperpipeNetworkSGIX), POINTER(Display), POINTER(c_int)) # GL/glxext.h:866
PFNGLXHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(GLXHyperpipeConfigSGIX), POINTER(c_int)) # GL/glxext.h:867
PFNGLXQUERYHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(POINTER(GLXHyperpipeConfigSGIX), POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:868
PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:869
PFNGLXBINDHYPERPIPESGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:870
PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None), POINTER(None)) # GL/glxext.h:871
PFNGLXHYPERPIPEATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None)) # GL/glxext.h:872
PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, c_int, POINTER(None)) # GL/glxext.h:873
# MESA_agp_offset (GL/glxext.h:876)
GLX_MESA_agp_offset = 1 # GL/glxext.h:877
# GL/glxext.h:879
glXGetAGPOffsetMESA = _link_function('glXGetAGPOffsetMESA', c_uint, [POINTER(None)], 'MESA_agp_offset')
PFNGLXGETAGPOFFSETMESAPROC = CFUNCTYPE(c_uint, POINTER(None)) # GL/glxext.h:881
# EXT_fbconfig_packed_float (GL/glxext.h:884)
GLX_EXT_fbconfig_packed_float = 1 # GL/glxext.h:885
# EXT_framebuffer_sRGB (GL/glxext.h:888)
GLX_EXT_framebuffer_sRGB = 1 # GL/glxext.h:889
# EXT_texture_from_pixmap (GL/glxext.h:892)
GLX_EXT_texture_from_pixmap = 1 # GL/glxext.h:893
# GL/glxext.h:895
glXBindTexImageEXT = _link_function('glXBindTexImageEXT', None, [POINTER(Display), GLXDrawable, c_int, POINTER(c_int)], 'EXT_texture_from_pixmap')
# GL/glxext.h:896
glXReleaseTexImageEXT = _link_function('glXReleaseTexImageEXT', None, [POINTER(Display), GLXDrawable, c_int], 'EXT_texture_from_pixmap')
PFNGLXBINDTEXIMAGEEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int, POINTER(c_int)) # GL/glxext.h:898
PFNGLXRELEASETEXIMAGEEXTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int) # GL/glxext.h:899
# NV_present_video (GL/glxext.h:902)
GLX_NV_present_video = 1 # GL/glxext.h:903
# GL/glxext.h:905
glXEnumerateVideoDevicesNV = _link_function('glXEnumerateVideoDevicesNV', POINTER(c_uint), [POINTER(Display), c_int, POINTER(c_int)], 'NV_present_video')
# GL/glxext.h:906
glXBindVideoDeviceNV = _link_function('glXBindVideoDeviceNV', c_int, [POINTER(Display), c_uint, c_uint, POINTER(c_int)], 'NV_present_video')
PFNGLXENUMERATEVIDEODEVICESNVPROC = CFUNCTYPE(POINTER(c_uint), POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:908
PFNGLXBINDVIDEODEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_uint, c_uint, POINTER(c_int)) # GL/glxext.h:909
# NV_video_output (GL/glxext.h:912)
GLX_NV_video_output = 1 # GL/glxext.h:913
# GL/glxext.h:915
glXGetVideoDeviceNV = _link_function('glXGetVideoDeviceNV', c_int, [POINTER(Display), c_int, c_int, POINTER(GLXVideoDeviceNV)], 'NV_video_output')
# GL/glxext.h:916
glXReleaseVideoDeviceNV = _link_function('glXReleaseVideoDeviceNV', c_int, [POINTER(Display), c_int, GLXVideoDeviceNV], 'NV_video_output')
GLXPbuffer = pyglet.gl.glx.GLXPbuffer
# GL/glxext.h:917
glXBindVideoImageNV = _link_function('glXBindVideoImageNV', c_int, [POINTER(Display), GLXVideoDeviceNV, GLXPbuffer, c_int], 'NV_video_output')
# GL/glxext.h:918
glXReleaseVideoImageNV = _link_function('glXReleaseVideoImageNV', c_int, [POINTER(Display), GLXPbuffer], 'NV_video_output')
GLboolean = c_ubyte # /usr/include/GL/gl.h:154
# GL/glxext.h:919
glXSendPbufferToVideoNV = _link_function('glXSendPbufferToVideoNV', c_int, [POINTER(Display), GLXPbuffer, c_int, POINTER(c_ulong), GLboolean], 'NV_video_output')
# GL/glxext.h:920
glXGetVideoInfoNV = _link_function('glXGetVideoInfoNV', c_int, [POINTER(Display), c_int, GLXVideoDeviceNV, POINTER(c_ulong), POINTER(c_ulong)], 'NV_video_output')
PFNGLXGETVIDEODEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, c_int, POINTER(GLXVideoDeviceNV)) # GL/glxext.h:922
PFNGLXRELEASEVIDEODEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, GLXVideoDeviceNV) # GL/glxext.h:923
PFNGLXBINDVIDEOIMAGENVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXVideoDeviceNV, GLXPbuffer, c_int) # GL/glxext.h:924
PFNGLXRELEASEVIDEOIMAGENVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbuffer) # GL/glxext.h:925
PFNGLXSENDPBUFFERTOVIDEONVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXPbuffer, c_int, POINTER(c_ulong), GLboolean) # GL/glxext.h:926
PFNGLXGETVIDEOINFONVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, GLXVideoDeviceNV, POINTER(c_ulong), POINTER(c_ulong)) # GL/glxext.h:927
# NV_swap_group (GL/glxext.h:930)
GLX_NV_swap_group = 1 # GL/glxext.h:931
GLuint = c_uint # /usr/include/GL/gl.h:162
# GL/glxext.h:933
glXJoinSwapGroupNV = _link_function('glXJoinSwapGroupNV', c_int, [POINTER(Display), GLXDrawable, GLuint], 'NV_swap_group')
# GL/glxext.h:934
glXBindSwapBarrierNV = _link_function('glXBindSwapBarrierNV', c_int, [POINTER(Display), GLuint, GLuint], 'NV_swap_group')
# GL/glxext.h:935
glXQuerySwapGroupNV = _link_function('glXQuerySwapGroupNV', c_int, [POINTER(Display), GLXDrawable, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:936
glXQueryMaxSwapGroupsNV = _link_function('glXQueryMaxSwapGroupsNV', c_int, [POINTER(Display), c_int, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:937
glXQueryFrameCountNV = _link_function('glXQueryFrameCountNV', c_int, [POINTER(Display), c_int, POINTER(GLuint)], 'NV_swap_group')
# GL/glxext.h:938
glXResetFrameCountNV = _link_function('glXResetFrameCountNV', c_int, [POINTER(Display), c_int], 'NV_swap_group')
PFNGLXJOINSWAPGROUPNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, GLuint) # GL/glxext.h:940
PFNGLXBINDSWAPBARRIERNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLuint, GLuint) # GL/glxext.h:941
PFNGLXQUERYSWAPGROUPNVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(GLuint), POINTER(GLuint)) # GL/glxext.h:942
PFNGLXQUERYMAXSWAPGROUPSNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(GLuint), POINTER(GLuint)) # GL/glxext.h:943
PFNGLXQUERYFRAMECOUNTNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int, POINTER(GLuint)) # GL/glxext.h:944
PFNGLXRESETFRAMECOUNTNVPROC = CFUNCTYPE(c_int, POINTER(Display), c_int) # GL/glxext.h:945
# NV_video_capture (GL/glxext.h:948)
GLX_NV_video_capture = 1 # GL/glxext.h:949
# GL/glxext.h:951
glXBindVideoCaptureDeviceNV = _link_function('glXBindVideoCaptureDeviceNV', c_int, [POINTER(Display), c_uint, GLXVideoCaptureDeviceNV], 'NV_video_capture')
# GL/glxext.h:952
glXEnumerateVideoCaptureDevicesNV = _link_function('glXEnumerateVideoCaptureDevicesNV', POINTER(GLXVideoCaptureDeviceNV), [POINTER(Display), c_int, POINTER(c_int)], 'NV_video_capture')
# GL/glxext.h:953
glXLockVideoCaptureDeviceNV = _link_function('glXLockVideoCaptureDeviceNV', None, [POINTER(Display), GLXVideoCaptureDeviceNV], 'NV_video_capture')
# GL/glxext.h:954
glXQueryVideoCaptureDeviceNV = _link_function('glXQueryVideoCaptureDeviceNV', c_int, [POINTER(Display), GLXVideoCaptureDeviceNV, c_int, POINTER(c_int)], 'NV_video_capture')
# GL/glxext.h:955
glXReleaseVideoCaptureDeviceNV = _link_function('glXReleaseVideoCaptureDeviceNV', None, [POINTER(Display), GLXVideoCaptureDeviceNV], 'NV_video_capture')
PFNGLXBINDVIDEOCAPTUREDEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), c_uint, GLXVideoCaptureDeviceNV) # GL/glxext.h:957
PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC = CFUNCTYPE(POINTER(GLXVideoCaptureDeviceNV), POINTER(Display), c_int, POINTER(c_int)) # GL/glxext.h:958
PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC = CFUNCTYPE(None, POINTER(Display), GLXVideoCaptureDeviceNV) # GL/glxext.h:959
PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC = CFUNCTYPE(c_int, POINTER(Display), GLXVideoCaptureDeviceNV, c_int, POINTER(c_int)) # GL/glxext.h:960
PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC = CFUNCTYPE(None, POINTER(Display), GLXVideoCaptureDeviceNV) # GL/glxext.h:961
# EXT_swap_control (GL/glxext.h:964)
GLX_EXT_swap_control = 1 # GL/glxext.h:965
# GL/glxext.h:967
glXSwapIntervalEXT = _link_function('glXSwapIntervalEXT', c_int, [POINTER(Display), GLXDrawable, c_int], 'EXT_swap_control')
PFNGLXSWAPINTERVALEXTPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, c_int) # GL/glxext.h:969
# NV_copy_image (GL/glxext.h:972)
GLX_NV_copy_image = 1 # GL/glxext.h:973
GLint = c_int # /usr/include/GL/gl.h:159
GLsizei = c_int # /usr/include/GL/gl.h:163
# GL/glxext.h:975
glXCopyImageSubDataNV = _link_function('glXCopyImageSubDataNV', None, [POINTER(Display), GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei], 'NV_copy_image')
PFNGLXCOPYIMAGESUBDATANVPROC = CFUNCTYPE(None, POINTER(Display), GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) # GL/glxext.h:977
# INTEL_swap_event (GL/glxext.h:980)
GLX_INTEL_swap_event = 1 # GL/glxext.h:981
# NV_multisample_coverage (GL/glxext.h:984)
GLX_NV_multisample_coverage = 1 # GL/glxext.h:985
# NV_vertex_array_range (/usr/include/GL/glx.h:349)
# MESA_allocate_memory (/usr/include/GL/glx.h:363)
# ARB_render_texture (/usr/include/GL/glx.h:380)
# NV_float_buffer (/usr/include/GL/glx.h:393)
# MESA_swap_frame_usage (/usr/include/GL/glx.h:405)
# MESA_swap_control (/usr/include/GL/glx.h:425)
# EXT_texture_from_pixmap (/usr/include/GL/glx.h:442)
__all__ = ['GLX_GLXEXT_VERSION', 'GLX_SAMPLE_BUFFERS_ARB', 'GLX_SAMPLES_ARB',
'GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB', 'GLX_RGBA_FLOAT_TYPE_ARB',
'GLX_RGBA_FLOAT_BIT_ARB', 'GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB',
'GLX_CONTEXT_DEBUG_BIT_ARB', 'GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB',
'GLX_CONTEXT_MAJOR_VERSION_ARB', 'GLX_CONTEXT_MINOR_VERSION_ARB',
'GLX_CONTEXT_FLAGS_ARB', 'GLX_CONTEXT_CORE_PROFILE_BIT_ARB',
'GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB', 'GLX_CONTEXT_PROFILE_MASK_ARB',
'GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB', 'GLX_LOSE_CONTEXT_ON_RESET_ARB',
'GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB',
'GLX_NO_RESET_NOTIFICATION_ARB', 'GLX_SAMPLE_BUFFERS_SGIS',
'GLX_SAMPLES_SGIS', 'GLX_X_VISUAL_TYPE_EXT', 'GLX_TRANSPARENT_TYPE_EXT',
'GLX_TRANSPARENT_INDEX_VALUE_EXT', 'GLX_TRANSPARENT_RED_VALUE_EXT',
'GLX_TRANSPARENT_GREEN_VALUE_EXT', 'GLX_TRANSPARENT_BLUE_VALUE_EXT',
'GLX_TRANSPARENT_ALPHA_VALUE_EXT', 'GLX_NONE_EXT', 'GLX_TRUE_COLOR_EXT',
'GLX_DIRECT_COLOR_EXT', 'GLX_PSEUDO_COLOR_EXT', 'GLX_STATIC_COLOR_EXT',
'GLX_GRAY_SCALE_EXT', 'GLX_STATIC_GRAY_EXT', 'GLX_TRANSPARENT_RGB_EXT',
'GLX_TRANSPARENT_INDEX_EXT', 'GLX_VISUAL_CAVEAT_EXT', 'GLX_SLOW_VISUAL_EXT',
'GLX_NON_CONFORMANT_VISUAL_EXT', 'GLX_SHARE_CONTEXT_EXT', 'GLX_VISUAL_ID_EXT',
'GLX_SCREEN_EXT', 'GLX_WINDOW_BIT_SGIX', 'GLX_PIXMAP_BIT_SGIX',
'GLX_RGBA_BIT_SGIX', 'GLX_COLOR_INDEX_BIT_SGIX', 'GLX_DRAWABLE_TYPE_SGIX',
'GLX_RENDER_TYPE_SGIX', 'GLX_X_RENDERABLE_SGIX', 'GLX_FBCONFIG_ID_SGIX',
'GLX_RGBA_TYPE_SGIX', 'GLX_COLOR_INDEX_TYPE_SGIX', 'GLX_PBUFFER_BIT_SGIX',
'GLX_BUFFER_CLOBBER_MASK_SGIX', 'GLX_FRONT_LEFT_BUFFER_BIT_SGIX',
'GLX_FRONT_RIGHT_BUFFER_BIT_SGIX', 'GLX_BACK_LEFT_BUFFER_BIT_SGIX',
'GLX_BACK_RIGHT_BUFFER_BIT_SGIX', 'GLX_AUX_BUFFERS_BIT_SGIX',
'GLX_DEPTH_BUFFER_BIT_SGIX', 'GLX_STENCIL_BUFFER_BIT_SGIX',
'GLX_ACCUM_BUFFER_BIT_SGIX', 'GLX_SAMPLE_BUFFERS_BIT_SGIX',
'GLX_MAX_PBUFFER_WIDTH_SGIX', 'GLX_MAX_PBUFFER_HEIGHT_SGIX',
'GLX_MAX_PBUFFER_PIXELS_SGIX', 'GLX_OPTIMAL_PBUFFER_WIDTH_SGIX',
'GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX', 'GLX_PRESERVED_CONTENTS_SGIX',
'GLX_LARGEST_PBUFFER_SGIX', 'GLX_WIDTH_SGIX', 'GLX_HEIGHT_SGIX',
'GLX_EVENT_MASK_SGIX', 'GLX_DAMAGED_SGIX', 'GLX_SAVED_SGIX',
'GLX_WINDOW_SGIX', 'GLX_PBUFFER_SGIX', 'GLX_SYNC_FRAME_SGIX',
'GLX_SYNC_SWAP_SGIX', 'GLX_DIGITAL_MEDIA_PBUFFER_SGIX',
'GLX_BLENDED_RGBA_SGIS', 'GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS',
'GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS', 'GLX_SAMPLE_BUFFERS_3DFX',
'GLX_SAMPLES_3DFX', 'GLX_3DFX_WINDOW_MODE_MESA',
'GLX_3DFX_FULLSCREEN_MODE_MESA', 'GLX_VISUAL_SELECT_GROUP_SGIX',
'GLX_SWAP_METHOD_OML', 'GLX_SWAP_EXCHANGE_OML', 'GLX_SWAP_COPY_OML',
'GLX_SWAP_UNDEFINED_OML', 'GLX_FLOAT_COMPONENTS_NV',
'GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX', 'GLX_BAD_HYPERPIPE_CONFIG_SGIX',
'GLX_BAD_HYPERPIPE_SGIX', 'GLX_HYPERPIPE_DISPLAY_PIPE_SGIX',
'GLX_HYPERPIPE_RENDER_PIPE_SGIX', 'GLX_PIPE_RECT_SGIX',
'GLX_PIPE_RECT_LIMITS_SGIX', 'GLX_HYPERPIPE_STEREO_SGIX',
'GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX', 'GLX_HYPERPIPE_ID_SGIX',
'GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT', 'GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT',
'GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT', 'GLX_TEXTURE_1D_BIT_EXT',
'GLX_TEXTURE_2D_BIT_EXT', 'GLX_TEXTURE_RECTANGLE_BIT_EXT',
'GLX_BIND_TO_TEXTURE_RGB_EXT', 'GLX_BIND_TO_TEXTURE_RGBA_EXT',
'GLX_BIND_TO_MIPMAP_TEXTURE_EXT', 'GLX_BIND_TO_TEXTURE_TARGETS_EXT',
'GLX_Y_INVERTED_EXT', 'GLX_TEXTURE_FORMAT_EXT', 'GLX_TEXTURE_TARGET_EXT',
'GLX_MIPMAP_TEXTURE_EXT', 'GLX_TEXTURE_FORMAT_NONE_EXT',
'GLX_TEXTURE_FORMAT_RGB_EXT', 'GLX_TEXTURE_FORMAT_RGBA_EXT',
'GLX_TEXTURE_1D_EXT', 'GLX_TEXTURE_2D_EXT', 'GLX_TEXTURE_RECTANGLE_EXT',
'GLX_FRONT_LEFT_EXT', 'GLX_FRONT_RIGHT_EXT', 'GLX_BACK_LEFT_EXT',
'GLX_BACK_RIGHT_EXT', 'GLX_FRONT_EXT', 'GLX_BACK_EXT', 'GLX_AUX0_EXT',
'GLX_AUX1_EXT', 'GLX_AUX2_EXT', 'GLX_AUX3_EXT', 'GLX_AUX4_EXT',
'GLX_AUX5_EXT', 'GLX_AUX6_EXT', 'GLX_AUX7_EXT', 'GLX_AUX8_EXT',
'GLX_AUX9_EXT', 'GLX_NUM_VIDEO_SLOTS_NV', 'GLX_VIDEO_OUT_COLOR_NV',
'GLX_VIDEO_OUT_ALPHA_NV', 'GLX_VIDEO_OUT_DEPTH_NV',
'GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV', 'GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV',
'GLX_VIDEO_OUT_FRAME_NV', 'GLX_VIDEO_OUT_FIELD_1_NV',
'GLX_VIDEO_OUT_FIELD_2_NV', 'GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV',
'GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV', 'GLX_DEVICE_ID_NV', 'GLX_UNIQUE_ID_NV',
'GLX_NUM_VIDEO_CAPTURE_SLOTS_NV', 'GLX_SWAP_INTERVAL_EXT',
'GLX_MAX_SWAP_INTERVAL_EXT', 'GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK',
'GLX_EXCHANGE_COMPLETE_INTEL', 'GLX_COPY_COMPLETE_INTEL',
'GLX_FLIP_COMPLETE_INTEL', 'GLX_COVERAGE_SAMPLES_NV', 'GLX_COLOR_SAMPLES_NV',
'GLX_GPU_VENDOR_AMD', 'GLX_GPU_RENDERER_STRING_AMD',
'GLX_GPU_OPENGL_VERSION_STRING_AMD', 'GLX_GPU_FASTEST_TARGET_GPUS_AMD',
'GLX_GPU_RAM_AMD', 'GLX_GPU_CLOCK_AMD', 'GLX_GPU_NUM_PIPES_AMD',
'GLX_GPU_NUM_SIMD_AMD', 'GLX_GPU_NUM_RB_AMD', 'GLX_GPU_NUM_SPI_AMD',
'GLX_CONTEXT_ES2_PROFILE_BIT_EXT', 'GLXVideoSourceSGIX', 'GLXFBConfigIDSGIX',
'GLXFBConfigSGIX', 'GLXPbufferSGIX', 'GLXBufferClobberEventSGIX',
'GLXVideoDeviceNV', 'GLXVideoCaptureDeviceNV', 'GLX_ARB_multisample',
'GLX_ARB_fbconfig_float', 'GLX_ARB_framebuffer_sRGB',
'GLX_ARB_create_context', 'glXCreateContextAttribsARB',
'PFNGLXCREATECONTEXTATTRIBSARBPROC', 'GLX_ARB_create_context_profile',
'GLX_ARB_create_context_robustness', 'GLX_SGIS_multisample',
'GLX_EXT_visual_info', 'GLX_SGI_swap_control', 'glXSwapIntervalSGI',
'PFNGLXSWAPINTERVALSGIPROC', 'GLX_SGI_video_sync', 'glXGetVideoSyncSGI',
'glXWaitVideoSyncSGI', 'PFNGLXGETVIDEOSYNCSGIPROC',
'PFNGLXWAITVIDEOSYNCSGIPROC', 'GLX_SGI_make_current_read',
'glXMakeCurrentReadSGI', 'glXGetCurrentReadDrawableSGI',
'PFNGLXMAKECURRENTREADSGIPROC', 'PFNGLXGETCURRENTREADDRAWABLESGIPROC',
'GLX_SGIX_video_source', 'GLX_EXT_visual_rating', 'GLX_EXT_import_context',
'glXGetCurrentDisplayEXT', 'glXQueryContextInfoEXT', 'glXGetContextIDEXT',
'glXImportContextEXT', 'glXFreeContextEXT', 'PFNGLXGETCURRENTDISPLAYEXTPROC',
'PFNGLXQUERYCONTEXTINFOEXTPROC', 'PFNGLXGETCONTEXTIDEXTPROC',
'PFNGLXIMPORTCONTEXTEXTPROC', 'PFNGLXFREECONTEXTEXTPROC', 'GLX_SGIX_fbconfig',
'glXGetFBConfigAttribSGIX', 'glXChooseFBConfigSGIX',
'glXCreateGLXPixmapWithConfigSGIX', 'glXCreateContextWithConfigSGIX',
'glXGetVisualFromFBConfigSGIX', 'glXGetFBConfigFromVisualSGIX',
'PFNGLXGETFBCONFIGATTRIBSGIXPROC', 'PFNGLXCHOOSEFBCONFIGSGIXPROC',
'PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC',
'PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC',
'PFNGLXGETVISUALFROMFBCONFIGSGIXPROC', 'PFNGLXGETFBCONFIGFROMVISUALSGIXPROC',
'GLX_SGIX_pbuffer', 'glXCreateGLXPbufferSGIX', 'glXDestroyGLXPbufferSGIX',
'glXQueryGLXPbufferSGIX', 'glXSelectEventSGIX', 'glXGetSelectedEventSGIX',
'PFNGLXCREATEGLXPBUFFERSGIXPROC', 'PFNGLXDESTROYGLXPBUFFERSGIXPROC',
'PFNGLXQUERYGLXPBUFFERSGIXPROC', 'PFNGLXSELECTEVENTSGIXPROC',
'PFNGLXGETSELECTEDEVENTSGIXPROC', 'GLX_SGI_cushion', 'glXCushionSGI',
'PFNGLXCUSHIONSGIPROC', 'GLX_SGIX_video_resize', 'glXBindChannelToWindowSGIX',
'glXChannelRectSGIX', 'glXQueryChannelRectSGIX', 'glXQueryChannelDeltasSGIX',
'glXChannelRectSyncSGIX', 'PFNGLXBINDCHANNELTOWINDOWSGIXPROC',
'PFNGLXCHANNELRECTSGIXPROC', 'PFNGLXQUERYCHANNELRECTSGIXPROC',
'PFNGLXQUERYCHANNELDELTASSGIXPROC', 'PFNGLXCHANNELRECTSYNCSGIXPROC',
'GLX_SGIX_dmbuffer', 'GLX_SGIX_swap_group', 'glXJoinSwapGroupSGIX',
'PFNGLXJOINSWAPGROUPSGIXPROC', 'GLX_SGIX_swap_barrier',
'glXBindSwapBarrierSGIX', 'glXQueryMaxSwapBarriersSGIX',
'PFNGLXBINDSWAPBARRIERSGIXPROC', 'PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC',
'GLX_SUN_get_transparent_index', 'glXGetTransparentIndexSUN',
'PFNGLXGETTRANSPARENTINDEXSUNPROC', 'GLX_MESA_copy_sub_buffer',
'glXCopySubBufferMESA', 'PFNGLXCOPYSUBBUFFERMESAPROC',
'GLX_MESA_pixmap_colormap', 'glXCreateGLXPixmapMESA',
'PFNGLXCREATEGLXPIXMAPMESAPROC', 'GLX_MESA_release_buffers',
'glXReleaseBuffersMESA', 'PFNGLXRELEASEBUFFERSMESAPROC',
'GLX_MESA_set_3dfx_mode', 'glXSet3DfxModeMESA', 'PFNGLXSET3DFXMODEMESAPROC',
'GLX_SGIX_visual_select_group', 'GLX_OML_swap_method', 'GLX_OML_sync_control',
'glXGetSyncValuesOML', 'glXGetMscRateOML', 'glXSwapBuffersMscOML',
'glXWaitForMscOML', 'glXWaitForSbcOML', 'PFNGLXGETSYNCVALUESOMLPROC',
'PFNGLXGETMSCRATEOMLPROC', 'PFNGLXSWAPBUFFERSMSCOMLPROC',
'PFNGLXWAITFORMSCOMLPROC', 'PFNGLXWAITFORSBCOMLPROC', 'GLX_NV_float_buffer',
'GLX_SGIX_hyperpipe', 'GLXHyperpipeNetworkSGIX', 'GLXHyperpipeConfigSGIX',
'GLXPipeRect', 'GLXPipeRectLimits', 'glXQueryHyperpipeNetworkSGIX',
'glXHyperpipeConfigSGIX', 'glXQueryHyperpipeConfigSGIX',
'glXDestroyHyperpipeConfigSGIX', 'glXBindHyperpipeSGIX',
'glXQueryHyperpipeBestAttribSGIX', 'glXHyperpipeAttribSGIX',
'glXQueryHyperpipeAttribSGIX', 'PFNGLXQUERYHYPERPIPENETWORKSGIXPROC',
'PFNGLXHYPERPIPECONFIGSGIXPROC', 'PFNGLXQUERYHYPERPIPECONFIGSGIXPROC',
'PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC', 'PFNGLXBINDHYPERPIPESGIXPROC',
'PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC', 'PFNGLXHYPERPIPEATTRIBSGIXPROC',
'PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC', 'GLX_MESA_agp_offset',
'glXGetAGPOffsetMESA', 'PFNGLXGETAGPOFFSETMESAPROC',
'GLX_EXT_fbconfig_packed_float', 'GLX_EXT_framebuffer_sRGB',
'GLX_EXT_texture_from_pixmap', 'glXBindTexImageEXT', 'glXReleaseTexImageEXT',
'PFNGLXBINDTEXIMAGEEXTPROC', 'PFNGLXRELEASETEXIMAGEEXTPROC',
'GLX_NV_present_video', 'glXEnumerateVideoDevicesNV', 'glXBindVideoDeviceNV',
'PFNGLXENUMERATEVIDEODEVICESNVPROC', 'PFNGLXBINDVIDEODEVICENVPROC',
'GLX_NV_video_output', 'glXGetVideoDeviceNV', 'glXReleaseVideoDeviceNV',
'glXBindVideoImageNV', 'glXReleaseVideoImageNV', 'glXSendPbufferToVideoNV',
'glXGetVideoInfoNV', 'PFNGLXGETVIDEODEVICENVPROC',
'PFNGLXRELEASEVIDEODEVICENVPROC', 'PFNGLXBINDVIDEOIMAGENVPROC',
'PFNGLXRELEASEVIDEOIMAGENVPROC', 'PFNGLXSENDPBUFFERTOVIDEONVPROC',
'PFNGLXGETVIDEOINFONVPROC', 'GLX_NV_swap_group', 'glXJoinSwapGroupNV',
'glXBindSwapBarrierNV', 'glXQuerySwapGroupNV', 'glXQueryMaxSwapGroupsNV',
'glXQueryFrameCountNV', 'glXResetFrameCountNV', 'PFNGLXJOINSWAPGROUPNVPROC',
'PFNGLXBINDSWAPBARRIERNVPROC', 'PFNGLXQUERYSWAPGROUPNVPROC',
'PFNGLXQUERYMAXSWAPGROUPSNVPROC', 'PFNGLXQUERYFRAMECOUNTNVPROC',
'PFNGLXRESETFRAMECOUNTNVPROC', 'GLX_NV_video_capture',
'glXBindVideoCaptureDeviceNV', 'glXEnumerateVideoCaptureDevicesNV',
'glXLockVideoCaptureDeviceNV', 'glXQueryVideoCaptureDeviceNV',
'glXReleaseVideoCaptureDeviceNV', 'PFNGLXBINDVIDEOCAPTUREDEVICENVPROC',
'PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC',
'PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC', 'PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC',
'PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC', 'GLX_EXT_swap_control',
'glXSwapIntervalEXT', 'PFNGLXSWAPINTERVALEXTPROC', 'GLX_NV_copy_image',
'glXCopyImageSubDataNV', 'PFNGLXCOPYIMAGESUBDATANVPROC',
'GLX_INTEL_swap_event', 'GLX_NV_multisample_coverage']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: lib_glx.py 597 2007-02-03 16:13:07Z Alex.Holkner $'
import ctypes
from ctypes import *
import pyglet
from pyglet.gl.lib import missing_function, decorate_function
from pyglet.compat import asbytes
__all__ = ['link_GL', 'link_GLU', 'link_WGL']
_debug_trace = pyglet.options['debug_trace']
gl_lib = ctypes.windll.opengl32
glu_lib = ctypes.windll.glu32
wgl_lib = gl_lib
if _debug_trace:
from pyglet.lib import _TraceLibrary
gl_lib = _TraceLibrary(gl_lib)
glu_lib = _TraceLibrary(glu_lib)
wgl_lib = _TraceLibrary(wgl_lib)
try:
wglGetProcAddress = wgl_lib.wglGetProcAddress
wglGetProcAddress.restype = CFUNCTYPE(POINTER(c_int))
wglGetProcAddress.argtypes = [c_char_p]
_have_get_proc_address = True
except AttributeError:
_have_get_proc_address = False
class WGLFunctionProxy(object):
__slots__ = ['name', 'requires', 'suggestions', 'ftype', 'func']
def __init__(self, name, ftype, requires, suggestions):
assert _have_get_proc_address
self.name = name
self.ftype = ftype
self.requires = requires
self.suggestions = suggestions
self.func = None
def __call__(self, *args, **kwargs):
if self.func:
return self.func(*args, **kwargs)
from pyglet.gl import current_context
if not current_context:
raise Exception(
'Call to function "%s" before GL context created' % self.name)
address = wglGetProcAddress(asbytes(self.name))
if cast(address, POINTER(c_int)): # check cast because address is func
self.func = cast(address, self.ftype)
decorate_function(self.func, self.name)
else:
self.func = missing_function(
self.name, self.requires, self.suggestions)
result = self.func(*args, **kwargs)
return result
def link_GL(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(gl_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
# Not in opengl32.dll. Try and get a pointer from WGL.
try:
fargs = (restype,) + tuple(argtypes)
ftype = ctypes.WINFUNCTYPE(*fargs)
if _have_get_proc_address:
from pyglet.gl import gl_info
if gl_info.have_context():
address = wglGetProcAddress(name)
if address:
func = cast(address, ftype)
decorate_function(func, name)
return func
else:
# Insert proxy until we have a context
return WGLFunctionProxy(name, ftype, requires, suggestions)
except:
pass
return missing_function(name, requires, suggestions)
def link_GLU(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(glu_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
# Not in glu32.dll. Try and get a pointer from WGL.
try:
fargs = (restype,) + tuple(argtypes)
ftype = ctypes.WINFUNCTYPE(*fargs)
if _have_get_proc_address:
from pyglet.gl import gl_info
if gl_info.have_context():
address = wglGetProcAddress(name)
if address:
func = cast(address, ftype)
decorate_function(func, name)
return func
else:
# Insert proxy until we have a context
return WGLFunctionProxy(name, ftype, requires, suggestions)
except:
pass
return missing_function(name, requires, suggestions)
link_WGL = link_GL
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for /usr/include/GL/glx.h
Do not modify generated portions of this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GLX as _link_function
from pyglet.gl.lib import c_ptrdiff_t, c_void
if not _link_function:
raise ImportError('libGL.so is not available.')
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for /usr/include/GL/glx.h
import pyglet.libs.x11.xlib
# H (/usr/include/GL/glx.h:26)
GLX_VERSION_1_1 = 1 # /usr/include/GL/glx.h:58
GLX_VERSION_1_2 = 1 # /usr/include/GL/glx.h:59
GLX_VERSION_1_3 = 1 # /usr/include/GL/glx.h:60
GLX_VERSION_1_4 = 1 # /usr/include/GL/glx.h:61
GLX_USE_GL = 1 # /usr/include/GL/glx.h:70
GLX_BUFFER_SIZE = 2 # /usr/include/GL/glx.h:71
GLX_LEVEL = 3 # /usr/include/GL/glx.h:72
GLX_RGBA = 4 # /usr/include/GL/glx.h:73
GLX_DOUBLEBUFFER = 5 # /usr/include/GL/glx.h:74
GLX_STEREO = 6 # /usr/include/GL/glx.h:75
GLX_AUX_BUFFERS = 7 # /usr/include/GL/glx.h:76
GLX_RED_SIZE = 8 # /usr/include/GL/glx.h:77
GLX_GREEN_SIZE = 9 # /usr/include/GL/glx.h:78
GLX_BLUE_SIZE = 10 # /usr/include/GL/glx.h:79
GLX_ALPHA_SIZE = 11 # /usr/include/GL/glx.h:80
GLX_DEPTH_SIZE = 12 # /usr/include/GL/glx.h:81
GLX_STENCIL_SIZE = 13 # /usr/include/GL/glx.h:82
GLX_ACCUM_RED_SIZE = 14 # /usr/include/GL/glx.h:83
GLX_ACCUM_GREEN_SIZE = 15 # /usr/include/GL/glx.h:84
GLX_ACCUM_BLUE_SIZE = 16 # /usr/include/GL/glx.h:85
GLX_ACCUM_ALPHA_SIZE = 17 # /usr/include/GL/glx.h:86
GLX_BAD_SCREEN = 1 # /usr/include/GL/glx.h:92
GLX_BAD_ATTRIBUTE = 2 # /usr/include/GL/glx.h:93
GLX_NO_EXTENSION = 3 # /usr/include/GL/glx.h:94
GLX_BAD_VISUAL = 4 # /usr/include/GL/glx.h:95
GLX_BAD_CONTEXT = 5 # /usr/include/GL/glx.h:96
GLX_BAD_VALUE = 6 # /usr/include/GL/glx.h:97
GLX_BAD_ENUM = 7 # /usr/include/GL/glx.h:98
GLX_VENDOR = 1 # /usr/include/GL/glx.h:104
GLX_VERSION = 2 # /usr/include/GL/glx.h:105
GLX_EXTENSIONS = 3 # /usr/include/GL/glx.h:106
GLX_CONFIG_CAVEAT = 32 # /usr/include/GL/glx.h:112
GLX_DONT_CARE = 4294967295 # /usr/include/GL/glx.h:113
GLX_X_VISUAL_TYPE = 34 # /usr/include/GL/glx.h:114
GLX_TRANSPARENT_TYPE = 35 # /usr/include/GL/glx.h:115
GLX_TRANSPARENT_INDEX_VALUE = 36 # /usr/include/GL/glx.h:116
GLX_TRANSPARENT_RED_VALUE = 37 # /usr/include/GL/glx.h:117
GLX_TRANSPARENT_GREEN_VALUE = 38 # /usr/include/GL/glx.h:118
GLX_TRANSPARENT_BLUE_VALUE = 39 # /usr/include/GL/glx.h:119
GLX_TRANSPARENT_ALPHA_VALUE = 40 # /usr/include/GL/glx.h:120
GLX_WINDOW_BIT = 1 # /usr/include/GL/glx.h:121
GLX_PIXMAP_BIT = 2 # /usr/include/GL/glx.h:122
GLX_PBUFFER_BIT = 4 # /usr/include/GL/glx.h:123
GLX_AUX_BUFFERS_BIT = 16 # /usr/include/GL/glx.h:124
GLX_FRONT_LEFT_BUFFER_BIT = 1 # /usr/include/GL/glx.h:125
GLX_FRONT_RIGHT_BUFFER_BIT = 2 # /usr/include/GL/glx.h:126
GLX_BACK_LEFT_BUFFER_BIT = 4 # /usr/include/GL/glx.h:127
GLX_BACK_RIGHT_BUFFER_BIT = 8 # /usr/include/GL/glx.h:128
GLX_DEPTH_BUFFER_BIT = 32 # /usr/include/GL/glx.h:129
GLX_STENCIL_BUFFER_BIT = 64 # /usr/include/GL/glx.h:130
GLX_ACCUM_BUFFER_BIT = 128 # /usr/include/GL/glx.h:131
GLX_NONE = 32768 # /usr/include/GL/glx.h:132
GLX_SLOW_CONFIG = 32769 # /usr/include/GL/glx.h:133
GLX_TRUE_COLOR = 32770 # /usr/include/GL/glx.h:134
GLX_DIRECT_COLOR = 32771 # /usr/include/GL/glx.h:135
GLX_PSEUDO_COLOR = 32772 # /usr/include/GL/glx.h:136
GLX_STATIC_COLOR = 32773 # /usr/include/GL/glx.h:137
GLX_GRAY_SCALE = 32774 # /usr/include/GL/glx.h:138
GLX_STATIC_GRAY = 32775 # /usr/include/GL/glx.h:139
GLX_TRANSPARENT_RGB = 32776 # /usr/include/GL/glx.h:140
GLX_TRANSPARENT_INDEX = 32777 # /usr/include/GL/glx.h:141
GLX_VISUAL_ID = 32779 # /usr/include/GL/glx.h:142
GLX_SCREEN = 32780 # /usr/include/GL/glx.h:143
GLX_NON_CONFORMANT_CONFIG = 32781 # /usr/include/GL/glx.h:144
GLX_DRAWABLE_TYPE = 32784 # /usr/include/GL/glx.h:145
GLX_RENDER_TYPE = 32785 # /usr/include/GL/glx.h:146
GLX_X_RENDERABLE = 32786 # /usr/include/GL/glx.h:147
GLX_FBCONFIG_ID = 32787 # /usr/include/GL/glx.h:148
GLX_RGBA_TYPE = 32788 # /usr/include/GL/glx.h:149
GLX_COLOR_INDEX_TYPE = 32789 # /usr/include/GL/glx.h:150
GLX_MAX_PBUFFER_WIDTH = 32790 # /usr/include/GL/glx.h:151
GLX_MAX_PBUFFER_HEIGHT = 32791 # /usr/include/GL/glx.h:152
GLX_MAX_PBUFFER_PIXELS = 32792 # /usr/include/GL/glx.h:153
GLX_PRESERVED_CONTENTS = 32795 # /usr/include/GL/glx.h:154
GLX_LARGEST_PBUFFER = 32796 # /usr/include/GL/glx.h:155
GLX_WIDTH = 32797 # /usr/include/GL/glx.h:156
GLX_HEIGHT = 32798 # /usr/include/GL/glx.h:157
GLX_EVENT_MASK = 32799 # /usr/include/GL/glx.h:158
GLX_DAMAGED = 32800 # /usr/include/GL/glx.h:159
GLX_SAVED = 32801 # /usr/include/GL/glx.h:160
GLX_WINDOW = 32802 # /usr/include/GL/glx.h:161
GLX_PBUFFER = 32803 # /usr/include/GL/glx.h:162
GLX_PBUFFER_HEIGHT = 32832 # /usr/include/GL/glx.h:163
GLX_PBUFFER_WIDTH = 32833 # /usr/include/GL/glx.h:164
GLX_RGBA_BIT = 1 # /usr/include/GL/glx.h:165
GLX_COLOR_INDEX_BIT = 2 # /usr/include/GL/glx.h:166
GLX_PBUFFER_CLOBBER_MASK = 134217728 # /usr/include/GL/glx.h:167
GLX_SAMPLE_BUFFERS = 100000 # /usr/include/GL/glx.h:173
GLX_SAMPLES = 100001 # /usr/include/GL/glx.h:174
class struct___GLXcontextRec(Structure):
__slots__ = [
]
struct___GLXcontextRec._fields_ = [
('_opaque_struct', c_int)
]
class struct___GLXcontextRec(Structure):
__slots__ = [
]
struct___GLXcontextRec._fields_ = [
('_opaque_struct', c_int)
]
GLXContext = POINTER(struct___GLXcontextRec) # /usr/include/GL/glx.h:178
XID = pyglet.libs.x11.xlib.XID
GLXPixmap = XID # /usr/include/GL/glx.h:179
GLXDrawable = XID # /usr/include/GL/glx.h:180
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
class struct___GLXFBConfigRec(Structure):
__slots__ = [
]
struct___GLXFBConfigRec._fields_ = [
('_opaque_struct', c_int)
]
GLXFBConfig = POINTER(struct___GLXFBConfigRec) # /usr/include/GL/glx.h:182
GLXFBConfigID = XID # /usr/include/GL/glx.h:183
GLXContextID = XID # /usr/include/GL/glx.h:184
GLXWindow = XID # /usr/include/GL/glx.h:185
GLXPbuffer = XID # /usr/include/GL/glx.h:186
XVisualInfo = pyglet.libs.x11.xlib.XVisualInfo
Display = pyglet.libs.x11.xlib.Display
# /usr/include/GL/glx.h:190
glXChooseVisual = _link_function('glXChooseVisual', POINTER(XVisualInfo), [POINTER(Display), c_int, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:193
glXCreateContext = _link_function('glXCreateContext', GLXContext, [POINTER(Display), POINTER(XVisualInfo), GLXContext, c_int], 'H')
# /usr/include/GL/glx.h:196
glXDestroyContext = _link_function('glXDestroyContext', None, [POINTER(Display), GLXContext], 'H')
# /usr/include/GL/glx.h:198
glXMakeCurrent = _link_function('glXMakeCurrent', c_int, [POINTER(Display), GLXDrawable, GLXContext], 'H')
# /usr/include/GL/glx.h:201
glXCopyContext = _link_function('glXCopyContext', None, [POINTER(Display), GLXContext, GLXContext, c_ulong], 'H')
# /usr/include/GL/glx.h:204
glXSwapBuffers = _link_function('glXSwapBuffers', None, [POINTER(Display), GLXDrawable], 'H')
Pixmap = pyglet.libs.x11.xlib.Pixmap
# /usr/include/GL/glx.h:206
glXCreateGLXPixmap = _link_function('glXCreateGLXPixmap', GLXPixmap, [POINTER(Display), POINTER(XVisualInfo), Pixmap], 'H')
# /usr/include/GL/glx.h:209
glXDestroyGLXPixmap = _link_function('glXDestroyGLXPixmap', None, [POINTER(Display), GLXPixmap], 'H')
# /usr/include/GL/glx.h:211
glXQueryExtension = _link_function('glXQueryExtension', c_int, [POINTER(Display), POINTER(c_int), POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:213
glXQueryVersion = _link_function('glXQueryVersion', c_int, [POINTER(Display), POINTER(c_int), POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:215
glXIsDirect = _link_function('glXIsDirect', c_int, [POINTER(Display), GLXContext], 'H')
# /usr/include/GL/glx.h:217
glXGetConfig = _link_function('glXGetConfig', c_int, [POINTER(Display), POINTER(XVisualInfo), c_int, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:220
glXGetCurrentContext = _link_function('glXGetCurrentContext', GLXContext, [], 'H')
# /usr/include/GL/glx.h:222
glXGetCurrentDrawable = _link_function('glXGetCurrentDrawable', GLXDrawable, [], 'H')
# /usr/include/GL/glx.h:224
glXWaitGL = _link_function('glXWaitGL', None, [], 'H')
# /usr/include/GL/glx.h:226
glXWaitX = _link_function('glXWaitX', None, [], 'H')
Font = pyglet.libs.x11.xlib.Font
# /usr/include/GL/glx.h:228
glXUseXFont = _link_function('glXUseXFont', None, [Font, c_int, c_int, c_int], 'H')
# /usr/include/GL/glx.h:233
glXQueryExtensionsString = _link_function('glXQueryExtensionsString', c_char_p, [POINTER(Display), c_int], 'H')
# /usr/include/GL/glx.h:235
glXQueryServerString = _link_function('glXQueryServerString', c_char_p, [POINTER(Display), c_int, c_int], 'H')
# /usr/include/GL/glx.h:237
glXGetClientString = _link_function('glXGetClientString', c_char_p, [POINTER(Display), c_int], 'H')
# /usr/include/GL/glx.h:241
glXGetCurrentDisplay = _link_function('glXGetCurrentDisplay', POINTER(Display), [], 'H')
# /usr/include/GL/glx.h:245
glXChooseFBConfig = _link_function('glXChooseFBConfig', POINTER(GLXFBConfig), [POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:248
glXGetFBConfigAttrib = _link_function('glXGetFBConfigAttrib', c_int, [POINTER(Display), GLXFBConfig, c_int, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:251
glXGetFBConfigs = _link_function('glXGetFBConfigs', POINTER(GLXFBConfig), [POINTER(Display), c_int, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:254
glXGetVisualFromFBConfig = _link_function('glXGetVisualFromFBConfig', POINTER(XVisualInfo), [POINTER(Display), GLXFBConfig], 'H')
Window = pyglet.libs.x11.xlib.Window
# /usr/include/GL/glx.h:257
glXCreateWindow = _link_function('glXCreateWindow', GLXWindow, [POINTER(Display), GLXFBConfig, Window, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:260
glXDestroyWindow = _link_function('glXDestroyWindow', None, [POINTER(Display), GLXWindow], 'H')
# /usr/include/GL/glx.h:262
glXCreatePixmap = _link_function('glXCreatePixmap', GLXPixmap, [POINTER(Display), GLXFBConfig, Pixmap, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:265
glXDestroyPixmap = _link_function('glXDestroyPixmap', None, [POINTER(Display), GLXPixmap], 'H')
# /usr/include/GL/glx.h:267
glXCreatePbuffer = _link_function('glXCreatePbuffer', GLXPbuffer, [POINTER(Display), GLXFBConfig, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:270
glXDestroyPbuffer = _link_function('glXDestroyPbuffer', None, [POINTER(Display), GLXPbuffer], 'H')
# /usr/include/GL/glx.h:272
glXQueryDrawable = _link_function('glXQueryDrawable', None, [POINTER(Display), GLXDrawable, c_int, POINTER(c_uint)], 'H')
# /usr/include/GL/glx.h:275
glXCreateNewContext = _link_function('glXCreateNewContext', GLXContext, [POINTER(Display), GLXFBConfig, c_int, GLXContext, c_int], 'H')
# /usr/include/GL/glx.h:279
glXMakeContextCurrent = _link_function('glXMakeContextCurrent', c_int, [POINTER(Display), GLXDrawable, GLXDrawable, GLXContext], 'H')
# /usr/include/GL/glx.h:282
glXGetCurrentReadDrawable = _link_function('glXGetCurrentReadDrawable', GLXDrawable, [], 'H')
# /usr/include/GL/glx.h:284
glXQueryContext = _link_function('glXQueryContext', c_int, [POINTER(Display), GLXContext, c_int, POINTER(c_int)], 'H')
# /usr/include/GL/glx.h:287
glXSelectEvent = _link_function('glXSelectEvent', None, [POINTER(Display), GLXDrawable, c_ulong], 'H')
# /usr/include/GL/glx.h:290
glXGetSelectedEvent = _link_function('glXGetSelectedEvent', None, [POINTER(Display), GLXDrawable, POINTER(c_ulong)], 'H')
PFNGLXGETFBCONFIGSPROC = CFUNCTYPE(POINTER(GLXFBConfig), POINTER(Display), c_int, POINTER(c_int)) # /usr/include/GL/glx.h:294
PFNGLXCHOOSEFBCONFIGPROC = CFUNCTYPE(POINTER(GLXFBConfig), POINTER(Display), c_int, POINTER(c_int), POINTER(c_int)) # /usr/include/GL/glx.h:295
PFNGLXGETFBCONFIGATTRIBPROC = CFUNCTYPE(c_int, POINTER(Display), GLXFBConfig, c_int, POINTER(c_int)) # /usr/include/GL/glx.h:296
PFNGLXGETVISUALFROMFBCONFIGPROC = CFUNCTYPE(POINTER(XVisualInfo), POINTER(Display), GLXFBConfig) # /usr/include/GL/glx.h:297
PFNGLXCREATEWINDOWPROC = CFUNCTYPE(GLXWindow, POINTER(Display), GLXFBConfig, Window, POINTER(c_int)) # /usr/include/GL/glx.h:298
PFNGLXDESTROYWINDOWPROC = CFUNCTYPE(None, POINTER(Display), GLXWindow) # /usr/include/GL/glx.h:299
PFNGLXCREATEPIXMAPPROC = CFUNCTYPE(GLXPixmap, POINTER(Display), GLXFBConfig, Pixmap, POINTER(c_int)) # /usr/include/GL/glx.h:300
PFNGLXDESTROYPIXMAPPROC = CFUNCTYPE(None, POINTER(Display), GLXPixmap) # /usr/include/GL/glx.h:301
PFNGLXCREATEPBUFFERPROC = CFUNCTYPE(GLXPbuffer, POINTER(Display), GLXFBConfig, POINTER(c_int)) # /usr/include/GL/glx.h:302
PFNGLXDESTROYPBUFFERPROC = CFUNCTYPE(None, POINTER(Display), GLXPbuffer) # /usr/include/GL/glx.h:303
PFNGLXQUERYDRAWABLEPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_int, POINTER(c_uint)) # /usr/include/GL/glx.h:304
PFNGLXCREATENEWCONTEXTPROC = CFUNCTYPE(GLXContext, POINTER(Display), GLXFBConfig, c_int, GLXContext, c_int) # /usr/include/GL/glx.h:305
PFNGLXMAKECONTEXTCURRENTPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, GLXDrawable, GLXContext) # /usr/include/GL/glx.h:306
PFNGLXGETCURRENTREADDRAWABLEPROC = CFUNCTYPE(GLXDrawable) # /usr/include/GL/glx.h:307
PFNGLXGETCURRENTDISPLAYPROC = CFUNCTYPE(POINTER(Display)) # /usr/include/GL/glx.h:308
PFNGLXQUERYCONTEXTPROC = CFUNCTYPE(c_int, POINTER(Display), GLXContext, c_int, POINTER(c_int)) # /usr/include/GL/glx.h:309
PFNGLXSELECTEVENTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, c_ulong) # /usr/include/GL/glx.h:310
PFNGLXGETSELECTEDEVENTPROC = CFUNCTYPE(None, POINTER(Display), GLXDrawable, POINTER(c_ulong)) # /usr/include/GL/glx.h:311
# ARB_get_proc_address (/usr/include/GL/glx.h:317)
GLX_ARB_get_proc_address = 1 # /usr/include/GL/glx.h:318
__GLXextFuncPtr = CFUNCTYPE(None) # /usr/include/GL/glx.h:320
GLubyte = c_ubyte # /usr/include/GL/gl.h:160
# /usr/include/GL/glx.h:321
glXGetProcAddressARB = _link_function('glXGetProcAddressARB', __GLXextFuncPtr, [POINTER(GLubyte)], 'ARB_get_proc_address')
# /usr/include/GL/glx.h:328
glXGetProcAddress = _link_function('glXGetProcAddress', POINTER(CFUNCTYPE(None)), [POINTER(GLubyte)], 'ARB_get_proc_address')
PFNGLXGETPROCADDRESSPROC = CFUNCTYPE(__GLXextFuncPtr, POINTER(GLubyte)) # /usr/include/GL/glx.h:331
# GLXEXT_LEGACY (/usr/include/GL/glx.h:334)
# VERSION_1_3 (/usr/include/GL/glxext.h:55)
# VERSION_1_4 (/usr/include/GL/glxext.h:114)
# ARB_get_proc_address (/usr/include/GL/glxext.h:119)
# ARB_multisample (/usr/include/GL/glxext.h:122)
# ARB_fbconfig_float (/usr/include/GL/glxext.h:127)
# ARB_create_context (/usr/include/GL/glxext.h:132)
# ARB_create_context_profile (/usr/include/GL/glxext.h:140)
# SGIS_multisample (/usr/include/GL/glxext.h:146)
# EXT_visual_info (/usr/include/GL/glxext.h:151)
# SGI_swap_control (/usr/include/GL/glxext.h:170)
# SGI_video_sync (/usr/include/GL/glxext.h:173)
# SGI_make_current_read (/usr/include/GL/glxext.h:176)
# SGIX_video_source (/usr/include/GL/glxext.h:179)
# EXT_visual_rating (/usr/include/GL/glxext.h:182)
# EXT_import_context (/usr/include/GL/glxext.h:189)
# SGIX_fbconfig (/usr/include/GL/glxext.h:195)
# SGIX_pbuffer (/usr/include/GL/glxext.h:209)
# SGI_cushion (/usr/include/GL/glxext.h:237)
# SGIX_video_resize (/usr/include/GL/glxext.h:240)
# SGIX_dmbuffer (/usr/include/GL/glxext.h:245)
# SGIX_swap_group (/usr/include/GL/glxext.h:249)
# SGIX_swap_barrier (/usr/include/GL/glxext.h:252)
# SGIS_blended_overlay (/usr/include/GL/glxext.h:255)
# SGIS_shared_multisample (/usr/include/GL/glxext.h:259)
# SUN_get_transparent_index (/usr/include/GL/glxext.h:264)
# 3DFX_multisample (/usr/include/GL/glxext.h:267)
# MESA_copy_sub_buffer (/usr/include/GL/glxext.h:272)
# MESA_pixmap_colormap (/usr/include/GL/glxext.h:275)
# MESA_release_buffers (/usr/include/GL/glxext.h:278)
# MESA_set_3dfx_mode (/usr/include/GL/glxext.h:281)
# SGIX_visual_select_group (/usr/include/GL/glxext.h:286)
# OML_swap_method (/usr/include/GL/glxext.h:290)
# OML_sync_control (/usr/include/GL/glxext.h:297)
# NV_float_buffer (/usr/include/GL/glxext.h:300)
# SGIX_hyperpipe (/usr/include/GL/glxext.h:304)
# MESA_agp_offset (/usr/include/GL/glxext.h:317)
# EXT_fbconfig_packed_float (/usr/include/GL/glxext.h:320)
# EXT_framebuffer_sRGB (/usr/include/GL/glxext.h:325)
# EXT_texture_from_pixmap (/usr/include/GL/glxext.h:329)
# NV_present_video (/usr/include/GL/glxext.h:365)
# NV_video_out (/usr/include/GL/glxext.h:369)
# NV_swap_group (/usr/include/GL/glxext.h:382)
# NV_video_capture (/usr/include/GL/glxext.h:385)
# EXT_swap_control (/usr/include/GL/glxext.h:391)
# NV_copy_image (/usr/include/GL/glxext.h:396)
# ARB_get_proc_address (/usr/include/GL/glxext.h:402)
# SGIX_video_source (/usr/include/GL/glxext.h:406)
# SGIX_fbconfig (/usr/include/GL/glxext.h:410)
# SGIX_pbuffer (/usr/include/GL/glxext.h:415)
# NV_video_output (/usr/include/GL/glxext.h:432)
# NV_video_capture (/usr/include/GL/glxext.h:436)
# VERSION_1_3 (/usr/include/GL/glxext.h:477)
# VERSION_1_4 (/usr/include/GL/glxext.h:519)
# ARB_get_proc_address (/usr/include/GL/glxext.h:527)
# ARB_multisample (/usr/include/GL/glxext.h:535)
# ARB_fbconfig_float (/usr/include/GL/glxext.h:539)
# ARB_create_context (/usr/include/GL/glxext.h:543)
# ARB_create_context_profile (/usr/include/GL/glxext.h:551)
# SGIS_multisample (/usr/include/GL/glxext.h:555)
# EXT_visual_info (/usr/include/GL/glxext.h:559)
# SGI_swap_control (/usr/include/GL/glxext.h:563)
# SGI_video_sync (/usr/include/GL/glxext.h:571)
# SGI_make_current_read (/usr/include/GL/glxext.h:581)
# SGIX_video_source (/usr/include/GL/glxext.h:591)
# EXT_visual_rating (/usr/include/GL/glxext.h:603)
# EXT_import_context (/usr/include/GL/glxext.h:607)
# SGIX_fbconfig (/usr/include/GL/glxext.h:623)
# SGIX_pbuffer (/usr/include/GL/glxext.h:641)
# SGI_cushion (/usr/include/GL/glxext.h:657)
# SGIX_video_resize (/usr/include/GL/glxext.h:665)
# SGIX_dmbuffer (/usr/include/GL/glxext.h:681)
# SGIX_swap_group (/usr/include/GL/glxext.h:691)
# SGIX_swap_barrier (/usr/include/GL/glxext.h:699)
# SUN_get_transparent_index (/usr/include/GL/glxext.h:709)
# MESA_copy_sub_buffer (/usr/include/GL/glxext.h:717)
# MESA_pixmap_colormap (/usr/include/GL/glxext.h:725)
# MESA_release_buffers (/usr/include/GL/glxext.h:733)
# MESA_set_3dfx_mode (/usr/include/GL/glxext.h:741)
# SGIX_visual_select_group (/usr/include/GL/glxext.h:749)
# OML_swap_method (/usr/include/GL/glxext.h:753)
# OML_sync_control (/usr/include/GL/glxext.h:757)
# NV_float_buffer (/usr/include/GL/glxext.h:773)
# SGIX_hyperpipe (/usr/include/GL/glxext.h:777)
# MESA_agp_offset (/usr/include/GL/glxext.h:824)
# EXT_fbconfig_packed_float (/usr/include/GL/glxext.h:832)
# EXT_framebuffer_sRGB (/usr/include/GL/glxext.h:836)
# EXT_texture_from_pixmap (/usr/include/GL/glxext.h:840)
# NV_present_video (/usr/include/GL/glxext.h:850)
# NV_video_output (/usr/include/GL/glxext.h:860)
# NV_swap_group (/usr/include/GL/glxext.h:878)
# NV_video_capture (/usr/include/GL/glxext.h:896)
# EXT_swap_control (/usr/include/GL/glxext.h:912)
# NV_copy_image (/usr/include/GL/glxext.h:920)
# NV_vertex_array_range (/usr/include/GL/glx.h:349)
GLsizei = c_int # /usr/include/GL/gl.h:163
GLfloat = c_float # /usr/include/GL/gl.h:164
# /usr/include/GL/glx.h:352
glXAllocateMemoryNV = _link_function('glXAllocateMemoryNV', POINTER(c_void), [GLsizei, GLfloat, GLfloat, GLfloat], 'NV_vertex_array_range')
GLvoid = None # /usr/include/GL/gl.h:156
# /usr/include/GL/glx.h:353
glXFreeMemoryNV = _link_function('glXFreeMemoryNV', None, [POINTER(GLvoid)], 'NV_vertex_array_range')
PFNGLXALLOCATEMEMORYNVPROC = CFUNCTYPE(POINTER(c_void), GLsizei, GLfloat, GLfloat, GLfloat) # /usr/include/GL/glx.h:354
PFNGLXFREEMEMORYNVPROC = CFUNCTYPE(None, POINTER(GLvoid)) # /usr/include/GL/glx.h:355
# MESA_allocate_memory (/usr/include/GL/glx.h:363)
GLX_MESA_allocate_memory = 1 # /usr/include/GL/glx.h:364
# /usr/include/GL/glx.h:366
glXAllocateMemoryMESA = _link_function('glXAllocateMemoryMESA', POINTER(c_void), [POINTER(Display), c_int, c_size_t, c_float, c_float, c_float], 'MESA_allocate_memory')
# /usr/include/GL/glx.h:367
glXFreeMemoryMESA = _link_function('glXFreeMemoryMESA', None, [POINTER(Display), c_int, POINTER(None)], 'MESA_allocate_memory')
GLuint = c_uint # /usr/include/GL/gl.h:162
# /usr/include/GL/glx.h:368
glXGetMemoryOffsetMESA = _link_function('glXGetMemoryOffsetMESA', GLuint, [POINTER(Display), c_int, POINTER(None)], 'MESA_allocate_memory')
PFNGLXALLOCATEMEMORYMESAPROC = CFUNCTYPE(POINTER(c_void), POINTER(Display), c_int, c_size_t, c_float, c_float, c_float) # /usr/include/GL/glx.h:369
PFNGLXFREEMEMORYMESAPROC = CFUNCTYPE(None, POINTER(Display), c_int, POINTER(None)) # /usr/include/GL/glx.h:370
PFNGLXGETMEMORYOFFSETMESAPROC = CFUNCTYPE(GLuint, POINTER(Display), c_int, POINTER(None)) # /usr/include/GL/glx.h:371
# ARB_render_texture (/usr/include/GL/glx.h:380)
GLX_ARB_render_texture = 1 # /usr/include/GL/glx.h:381
# /usr/include/GL/glx.h:383
glXBindTexImageARB = _link_function('glXBindTexImageARB', c_int, [POINTER(Display), GLXPbuffer, c_int], 'ARB_render_texture')
# /usr/include/GL/glx.h:384
glXReleaseTexImageARB = _link_function('glXReleaseTexImageARB', c_int, [POINTER(Display), GLXPbuffer, c_int], 'ARB_render_texture')
# /usr/include/GL/glx.h:385
glXDrawableAttribARB = _link_function('glXDrawableAttribARB', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int)], 'ARB_render_texture')
# NV_float_buffer (/usr/include/GL/glx.h:393)
# MESA_swap_frame_usage (/usr/include/GL/glx.h:405)
GLX_MESA_swap_frame_usage = 1 # /usr/include/GL/glx.h:406
# /usr/include/GL/glx.h:408
glXGetFrameUsageMESA = _link_function('glXGetFrameUsageMESA', c_int, [POINTER(Display), GLXDrawable, POINTER(c_float)], 'MESA_swap_frame_usage')
# /usr/include/GL/glx.h:409
glXBeginFrameTrackingMESA = _link_function('glXBeginFrameTrackingMESA', c_int, [POINTER(Display), GLXDrawable], 'MESA_swap_frame_usage')
# /usr/include/GL/glx.h:410
glXEndFrameTrackingMESA = _link_function('glXEndFrameTrackingMESA', c_int, [POINTER(Display), GLXDrawable], 'MESA_swap_frame_usage')
# /usr/include/GL/glx.h:411
glXQueryFrameTrackingMESA = _link_function('glXQueryFrameTrackingMESA', c_int, [POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_float)], 'MESA_swap_frame_usage')
PFNGLXGETFRAMEUSAGEMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_float)) # /usr/include/GL/glx.h:413
PFNGLXBEGINFRAMETRACKINGMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable) # /usr/include/GL/glx.h:414
PFNGLXENDFRAMETRACKINGMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable) # /usr/include/GL/glx.h:415
PFNGLXQUERYFRAMETRACKINGMESAPROC = CFUNCTYPE(c_int, POINTER(Display), GLXDrawable, POINTER(c_int64), POINTER(c_int64), POINTER(c_float)) # /usr/include/GL/glx.h:416
# MESA_swap_control (/usr/include/GL/glx.h:425)
GLX_MESA_swap_control = 1 # /usr/include/GL/glx.h:426
# /usr/include/GL/glx.h:428
glXSwapIntervalMESA = _link_function('glXSwapIntervalMESA', c_int, [c_uint], 'MESA_swap_control')
# /usr/include/GL/glx.h:429
glXGetSwapIntervalMESA = _link_function('glXGetSwapIntervalMESA', c_int, [], 'MESA_swap_control')
PFNGLXSWAPINTERVALMESAPROC = CFUNCTYPE(c_int, c_uint) # /usr/include/GL/glx.h:431
PFNGLXGETSWAPINTERVALMESAPROC = CFUNCTYPE(c_int) # /usr/include/GL/glx.h:432
# EXT_texture_from_pixmap (/usr/include/GL/glx.h:442)
class struct_anon_111(Structure):
__slots__ = [
'event_type',
'draw_type',
'serial',
'send_event',
'display',
'drawable',
'buffer_mask',
'aux_buffer',
'x',
'y',
'width',
'height',
'count',
]
struct_anon_111._fields_ = [
('event_type', c_int),
('draw_type', c_int),
('serial', c_ulong),
('send_event', c_int),
('display', POINTER(Display)),
('drawable', GLXDrawable),
('buffer_mask', c_uint),
('aux_buffer', c_uint),
('x', c_int),
('y', c_int),
('width', c_int),
('height', c_int),
('count', c_int),
]
GLXPbufferClobberEvent = struct_anon_111 # /usr/include/GL/glx.h:508
class struct___GLXEvent(Union):
__slots__ = [
'glxpbufferclobber',
'pad',
]
struct___GLXEvent._fields_ = [
('glxpbufferclobber', GLXPbufferClobberEvent),
('pad', c_long * 24),
]
GLXEvent = struct___GLXEvent # /usr/include/GL/glx.h:513
__all__ = ['GLX_VERSION_1_1', 'GLX_VERSION_1_2', 'GLX_VERSION_1_3',
'GLX_VERSION_1_4', 'GLX_USE_GL', 'GLX_BUFFER_SIZE', 'GLX_LEVEL', 'GLX_RGBA',
'GLX_DOUBLEBUFFER', 'GLX_STEREO', 'GLX_AUX_BUFFERS', 'GLX_RED_SIZE',
'GLX_GREEN_SIZE', 'GLX_BLUE_SIZE', 'GLX_ALPHA_SIZE', 'GLX_DEPTH_SIZE',
'GLX_STENCIL_SIZE', 'GLX_ACCUM_RED_SIZE', 'GLX_ACCUM_GREEN_SIZE',
'GLX_ACCUM_BLUE_SIZE', 'GLX_ACCUM_ALPHA_SIZE', 'GLX_BAD_SCREEN',
'GLX_BAD_ATTRIBUTE', 'GLX_NO_EXTENSION', 'GLX_BAD_VISUAL', 'GLX_BAD_CONTEXT',
'GLX_BAD_VALUE', 'GLX_BAD_ENUM', 'GLX_VENDOR', 'GLX_VERSION',
'GLX_EXTENSIONS', 'GLX_CONFIG_CAVEAT', 'GLX_DONT_CARE', 'GLX_X_VISUAL_TYPE',
'GLX_TRANSPARENT_TYPE', 'GLX_TRANSPARENT_INDEX_VALUE',
'GLX_TRANSPARENT_RED_VALUE', 'GLX_TRANSPARENT_GREEN_VALUE',
'GLX_TRANSPARENT_BLUE_VALUE', 'GLX_TRANSPARENT_ALPHA_VALUE', 'GLX_WINDOW_BIT',
'GLX_PIXMAP_BIT', 'GLX_PBUFFER_BIT', 'GLX_AUX_BUFFERS_BIT',
'GLX_FRONT_LEFT_BUFFER_BIT', 'GLX_FRONT_RIGHT_BUFFER_BIT',
'GLX_BACK_LEFT_BUFFER_BIT', 'GLX_BACK_RIGHT_BUFFER_BIT',
'GLX_DEPTH_BUFFER_BIT', 'GLX_STENCIL_BUFFER_BIT', 'GLX_ACCUM_BUFFER_BIT',
'GLX_NONE', 'GLX_SLOW_CONFIG', 'GLX_TRUE_COLOR', 'GLX_DIRECT_COLOR',
'GLX_PSEUDO_COLOR', 'GLX_STATIC_COLOR', 'GLX_GRAY_SCALE', 'GLX_STATIC_GRAY',
'GLX_TRANSPARENT_RGB', 'GLX_TRANSPARENT_INDEX', 'GLX_VISUAL_ID', 'GLX_SCREEN',
'GLX_NON_CONFORMANT_CONFIG', 'GLX_DRAWABLE_TYPE', 'GLX_RENDER_TYPE',
'GLX_X_RENDERABLE', 'GLX_FBCONFIG_ID', 'GLX_RGBA_TYPE',
'GLX_COLOR_INDEX_TYPE', 'GLX_MAX_PBUFFER_WIDTH', 'GLX_MAX_PBUFFER_HEIGHT',
'GLX_MAX_PBUFFER_PIXELS', 'GLX_PRESERVED_CONTENTS', 'GLX_LARGEST_PBUFFER',
'GLX_WIDTH', 'GLX_HEIGHT', 'GLX_EVENT_MASK', 'GLX_DAMAGED', 'GLX_SAVED',
'GLX_WINDOW', 'GLX_PBUFFER', 'GLX_PBUFFER_HEIGHT', 'GLX_PBUFFER_WIDTH',
'GLX_RGBA_BIT', 'GLX_COLOR_INDEX_BIT', 'GLX_PBUFFER_CLOBBER_MASK',
'GLX_SAMPLE_BUFFERS', 'GLX_SAMPLES', 'GLXContext', 'GLXPixmap', 'GLXDrawable',
'GLXFBConfig', 'GLXFBConfigID', 'GLXContextID', 'GLXWindow', 'GLXPbuffer',
'glXChooseVisual', 'glXCreateContext', 'glXDestroyContext', 'glXMakeCurrent',
'glXCopyContext', 'glXSwapBuffers', 'glXCreateGLXPixmap',
'glXDestroyGLXPixmap', 'glXQueryExtension', 'glXQueryVersion', 'glXIsDirect',
'glXGetConfig', 'glXGetCurrentContext', 'glXGetCurrentDrawable', 'glXWaitGL',
'glXWaitX', 'glXUseXFont', 'glXQueryExtensionsString', 'glXQueryServerString',
'glXGetClientString', 'glXGetCurrentDisplay', 'glXChooseFBConfig',
'glXGetFBConfigAttrib', 'glXGetFBConfigs', 'glXGetVisualFromFBConfig',
'glXCreateWindow', 'glXDestroyWindow', 'glXCreatePixmap', 'glXDestroyPixmap',
'glXCreatePbuffer', 'glXDestroyPbuffer', 'glXQueryDrawable',
'glXCreateNewContext', 'glXMakeContextCurrent', 'glXGetCurrentReadDrawable',
'glXQueryContext', 'glXSelectEvent', 'glXGetSelectedEvent',
'PFNGLXGETFBCONFIGSPROC', 'PFNGLXCHOOSEFBCONFIGPROC',
'PFNGLXGETFBCONFIGATTRIBPROC', 'PFNGLXGETVISUALFROMFBCONFIGPROC',
'PFNGLXCREATEWINDOWPROC', 'PFNGLXDESTROYWINDOWPROC', 'PFNGLXCREATEPIXMAPPROC',
'PFNGLXDESTROYPIXMAPPROC', 'PFNGLXCREATEPBUFFERPROC',
'PFNGLXDESTROYPBUFFERPROC', 'PFNGLXQUERYDRAWABLEPROC',
'PFNGLXCREATENEWCONTEXTPROC', 'PFNGLXMAKECONTEXTCURRENTPROC',
'PFNGLXGETCURRENTREADDRAWABLEPROC', 'PFNGLXGETCURRENTDISPLAYPROC',
'PFNGLXQUERYCONTEXTPROC', 'PFNGLXSELECTEVENTPROC',
'PFNGLXGETSELECTEDEVENTPROC', 'GLX_ARB_get_proc_address', '__GLXextFuncPtr',
'glXGetProcAddressARB', 'glXGetProcAddress', 'PFNGLXGETPROCADDRESSPROC',
'glXAllocateMemoryNV', 'glXFreeMemoryNV', 'PFNGLXALLOCATEMEMORYNVPROC',
'PFNGLXFREEMEMORYNVPROC', 'GLX_MESA_allocate_memory', 'glXAllocateMemoryMESA',
'glXFreeMemoryMESA', 'glXGetMemoryOffsetMESA', 'PFNGLXALLOCATEMEMORYMESAPROC',
'PFNGLXFREEMEMORYMESAPROC', 'PFNGLXGETMEMORYOFFSETMESAPROC',
'GLX_ARB_render_texture', 'glXBindTexImageARB', 'glXReleaseTexImageARB',
'glXDrawableAttribARB', 'GLX_MESA_swap_frame_usage', 'glXGetFrameUsageMESA',
'glXBeginFrameTrackingMESA', 'glXEndFrameTrackingMESA',
'glXQueryFrameTrackingMESA', 'PFNGLXGETFRAMEUSAGEMESAPROC',
'PFNGLXBEGINFRAMETRACKINGMESAPROC', 'PFNGLXENDFRAMETRACKINGMESAPROC',
'PFNGLXQUERYFRAMETRACKINGMESAPROC', 'GLX_MESA_swap_control',
'glXSwapIntervalMESA', 'glXGetSwapIntervalMESA', 'PFNGLXSWAPINTERVALMESAPROC',
'PFNGLXGETSWAPINTERVALMESAPROC', 'GLXPbufferClobberEvent', 'GLXEvent']
# END GENERATED CONTENT (do not edit above this line)
# From glxproto.h
GLXBadContext = 0
GLXBadContextState = 1
GLXBadDrawable = 2
GLXBadPixmap = 3
GLXBadContextTag = 4
GLXBadCurrentWindow = 5
GLXBadRenderRequest = 6
GLXBadLargeRequest = 7
GLXUnsupportedPrivateRequest = 8
GLXBadFBConfig = 9
GLXBadPbuffer = 10
GLXBadCurrentDrawable = 11
GLXBadWindow = 12
__all__ += ['GLXBadContext', 'GLXBadContextState', 'GLXBadDrawable',
'GLXBadPixmap', 'GLXBadContextTag', 'GLXBadCurrentWindow',
'GLXBadRenderRequest', 'GLXBadLargeRequest', 'GLXUnsupportedPrivateRequest',
'GLXBadFBConfig', 'GLXBadPbuffer', 'GLXBadCurrentDrawable', 'GLXBadWindow']
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from base import Config, CanvasConfig, Context
from pyglet.libs.darwin import *
from pyglet.libs.darwin import _oscheck
from pyglet.gl import ContextException
from pyglet.gl import gl
from pyglet.gl import agl
from pyglet.canvas.carbon import CarbonCanvas, CarbonFullScreenCanvas
def _aglcheck():
err = agl.aglGetError()
if err != agl.AGL_NO_ERROR:
raise RuntimeError(cast(agl.aglErrorString(err), c_char_p).value)
class CarbonConfig(Config):
def match(self, canvas):
# Construct array of attributes for aglChoosePixelFormat
attrs = []
for name, value in self.get_gl_attributes():
attr = CarbonCanvasConfig._attribute_ids.get(name, None)
if not attr or not value:
continue
attrs.append(attr)
if attr not in CarbonCanvasConfig._boolean_attributes:
attrs.append(int(value))
# Support for RAGE-II, which is not compliant
attrs.append(agl.AGL_ALL_RENDERERS)
# Force selection policy and RGBA
attrs.append(agl.AGL_MAXIMUM_POLICY)
attrs.append(agl.AGL_RGBA)
# In 10.3 and later, AGL_FULLSCREEN is specified so the window can
# be toggled to/from fullscreen without losing context. pyglet
# no longer supports earlier versions of OS X, so we always supply it.
attrs.append(agl.AGL_FULLSCREEN)
# Terminate the list.
attrs.append(agl.AGL_NONE)
attrib_list = (c_int * len(attrs))(*attrs)
gdevice = cast(canvas.screen.get_gdevice(), agl.GDHandle)
pformat = agl.aglChoosePixelFormat(gdevice, 1, attrib_list)
_aglcheck()
if not pformat:
return []
else:
return [CarbonCanvasConfig(canvas, self, pformat, self)]
class CarbonCanvasConfig(CanvasConfig):
# Valid names for GL attributes, and their corresponding AGL constant.
_attribute_ids = {
'double_buffer': agl.AGL_DOUBLEBUFFER,
'stereo': agl.AGL_STEREO,
'buffer_size': agl.AGL_BUFFER_SIZE,
'sample_buffers': agl.AGL_SAMPLE_BUFFERS_ARB,
'samples': agl.AGL_SAMPLES_ARB,
'aux_buffers': agl.AGL_AUX_BUFFERS,
'red_size': agl.AGL_RED_SIZE,
'green_size': agl.AGL_GREEN_SIZE,
'blue_size': agl.AGL_BLUE_SIZE,
'alpha_size': agl.AGL_ALPHA_SIZE,
'depth_size': agl.AGL_DEPTH_SIZE,
'stencil_size': agl.AGL_STENCIL_SIZE,
'accum_red_size': agl.AGL_ACCUM_RED_SIZE,
'accum_green_size': agl.AGL_ACCUM_GREEN_SIZE,
'accum_blue_size': agl.AGL_ACCUM_BLUE_SIZE,
'accum_alpha_size': agl.AGL_ACCUM_ALPHA_SIZE,
# Not exposed by pyglet API (set internally)
'all_renderers': agl.AGL_ALL_RENDERERS,
'rgba': agl.AGL_RGBA,
'fullscreen': agl.AGL_FULLSCREEN,
'minimum_policy': agl.AGL_MINIMUM_POLICY,
'maximum_policy': agl.AGL_MAXIMUM_POLICY,
# Not supported in current pyglet API
'level': agl.AGL_LEVEL,
'pixel_size': agl.AGL_PIXEL_SIZE, # == buffer_size
'aux_depth_stencil': agl.AGL_AUX_DEPTH_STENCIL,
'color_float': agl.AGL_COLOR_FLOAT,
'offscreen': agl.AGL_OFFSCREEN,
'sample_alpha': agl.AGL_SAMPLE_ALPHA,
'multisample': agl.AGL_MULTISAMPLE,
'supersample': agl.AGL_SUPERSAMPLE,
}
# AGL constants which do not require a value.
_boolean_attributes = \
(agl.AGL_ALL_RENDERERS,
agl.AGL_RGBA,
agl.AGL_DOUBLEBUFFER,
agl.AGL_STEREO,
agl.AGL_MINIMUM_POLICY,
agl.AGL_MAXIMUM_POLICY,
agl.AGL_OFFSCREEN,
agl.AGL_FULLSCREEN,
agl.AGL_AUX_DEPTH_STENCIL,
agl.AGL_COLOR_FLOAT,
agl.AGL_MULTISAMPLE,
agl.AGL_SUPERSAMPLE,
agl.AGL_SAMPLE_ALPHA)
def __init__(self, canvas, screen, pformat, config):
super(CarbonCanvasConfig, self).__init__(canvas, config)
self.screen = screen
self._pformat = pformat
self._attributes = {}
for name, attr in self._attribute_ids.items():
value = c_int()
result = agl.aglDescribePixelFormat(pformat, attr, byref(value))
if result:
setattr(self, name, value.value)
def create_context(self, share):
if share:
context = agl.aglCreateContext(self._pformat, share._context)
else:
context = agl.aglCreateContext(self._pformat, None)
_aglcheck()
return CarbonContext(self, context, share, self._pformat)
def compatible(self, canvas):
return isinstance(canvas, CarbonCanvas) or \
isinstance(canvas, CarbonFullScreenCanvas)
class CarbonContext(Context):
def __init__(self, config, context, share, pixelformat):
super(CarbonContext, self).__init__(share)
self.config = config
self._context = context
self._pixelformat = pixelformat
def attach(self, canvas):
if self.config._requires_gl_3():
raise ContextException('AGL does not support OpenGL 3')
super(CarbonContext, self).attach(canvas)
if isinstance(canvas, CarbonFullScreenCanvas):
# XXX not used any more (cannot use AGL_BUFFER_RECT)
agl.aglEnable(self._context, agl.AGL_FS_CAPTURE_SINGLE)
agl.aglSetFullScreen(self._context, canvas.width, canvas.height,
canvas.screen._refresh_rate, 0)
else:
agl.aglSetDrawable(self._context,
cast(canvas.drawable, agl.AGLDrawable))
agl.aglSetCurrentContext(self._context)
if canvas.bounds is not None:
bounds = (gl.GLint * 4)(*canvas.bounds)
agl.aglSetInteger(self._context, agl.AGL_BUFFER_RECT, bounds)
agl.aglEnable(self._context, agl.AGL_BUFFER_RECT)
else:
agl.aglDisable(self._context, agl.AGL_BUFFER_RECT)
_aglcheck()
self.set_current()
def detach(self):
super(CarbonContext, self).detach()
agl.aglSetDrawable(self._context, None)
_aglcheck()
def set_current(self):
super(CarbonContext, self).set_current()
agl.aglSetCurrentContext(self._context)
_aglcheck()
def update_geometry(self):
agl.aglUpdateContext(self._context)
_aglcheck()
def destroy(self):
super(CarbonContext, self).destroy()
agl.aglDestroyContext(self._context)
def set_vsync(self, vsync=True):
swap = c_long(int(vsync))
agl.aglSetInteger(self._context, agl.AGL_SWAP_INTERVAL, byref(swap))
_aglcheck()
def get_vsync(self):
swap = c_long()
agl.aglGetInteger(self._context, agl.AGL_SWAP_INTERVAL, byref(swap))
_aglcheck()
return bool(swap.value)
def flip(self):
agl.aglSwapBuffers(self._context)
_aglcheck()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for /usr/include/GL/glu.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GLU as _link_function
from pyglet.gl.lib import c_ptrdiff_t
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for /usr/include/GL/glu.h
GLU_EXT_object_space_tess = 1 # /usr/include/GL/glu.h:71
GLU_EXT_nurbs_tessellator = 1 # /usr/include/GL/glu.h:72
GLU_FALSE = 0 # /usr/include/GL/glu.h:75
GLU_TRUE = 1 # /usr/include/GL/glu.h:76
GLU_VERSION_1_1 = 1 # /usr/include/GL/glu.h:79
GLU_VERSION_1_2 = 1 # /usr/include/GL/glu.h:80
GLU_VERSION_1_3 = 1 # /usr/include/GL/glu.h:81
GLU_VERSION = 100800 # /usr/include/GL/glu.h:84
GLU_EXTENSIONS = 100801 # /usr/include/GL/glu.h:85
GLU_INVALID_ENUM = 100900 # /usr/include/GL/glu.h:88
GLU_INVALID_VALUE = 100901 # /usr/include/GL/glu.h:89
GLU_OUT_OF_MEMORY = 100902 # /usr/include/GL/glu.h:90
GLU_INCOMPATIBLE_GL_VERSION = 100903 # /usr/include/GL/glu.h:91
GLU_INVALID_OPERATION = 100904 # /usr/include/GL/glu.h:92
GLU_OUTLINE_POLYGON = 100240 # /usr/include/GL/glu.h:96
GLU_OUTLINE_PATCH = 100241 # /usr/include/GL/glu.h:97
GLU_NURBS_ERROR = 100103 # /usr/include/GL/glu.h:100
GLU_ERROR = 100103 # /usr/include/GL/glu.h:101
GLU_NURBS_BEGIN = 100164 # /usr/include/GL/glu.h:102
GLU_NURBS_BEGIN_EXT = 100164 # /usr/include/GL/glu.h:103
GLU_NURBS_VERTEX = 100165 # /usr/include/GL/glu.h:104
GLU_NURBS_VERTEX_EXT = 100165 # /usr/include/GL/glu.h:105
GLU_NURBS_NORMAL = 100166 # /usr/include/GL/glu.h:106
GLU_NURBS_NORMAL_EXT = 100166 # /usr/include/GL/glu.h:107
GLU_NURBS_COLOR = 100167 # /usr/include/GL/glu.h:108
GLU_NURBS_COLOR_EXT = 100167 # /usr/include/GL/glu.h:109
GLU_NURBS_TEXTURE_COORD = 100168 # /usr/include/GL/glu.h:110
GLU_NURBS_TEX_COORD_EXT = 100168 # /usr/include/GL/glu.h:111
GLU_NURBS_END = 100169 # /usr/include/GL/glu.h:112
GLU_NURBS_END_EXT = 100169 # /usr/include/GL/glu.h:113
GLU_NURBS_BEGIN_DATA = 100170 # /usr/include/GL/glu.h:114
GLU_NURBS_BEGIN_DATA_EXT = 100170 # /usr/include/GL/glu.h:115
GLU_NURBS_VERTEX_DATA = 100171 # /usr/include/GL/glu.h:116
GLU_NURBS_VERTEX_DATA_EXT = 100171 # /usr/include/GL/glu.h:117
GLU_NURBS_NORMAL_DATA = 100172 # /usr/include/GL/glu.h:118
GLU_NURBS_NORMAL_DATA_EXT = 100172 # /usr/include/GL/glu.h:119
GLU_NURBS_COLOR_DATA = 100173 # /usr/include/GL/glu.h:120
GLU_NURBS_COLOR_DATA_EXT = 100173 # /usr/include/GL/glu.h:121
GLU_NURBS_TEXTURE_COORD_DATA = 100174 # /usr/include/GL/glu.h:122
GLU_NURBS_TEX_COORD_DATA_EXT = 100174 # /usr/include/GL/glu.h:123
GLU_NURBS_END_DATA = 100175 # /usr/include/GL/glu.h:124
GLU_NURBS_END_DATA_EXT = 100175 # /usr/include/GL/glu.h:125
GLU_NURBS_ERROR1 = 100251 # /usr/include/GL/glu.h:128
GLU_NURBS_ERROR2 = 100252 # /usr/include/GL/glu.h:129
GLU_NURBS_ERROR3 = 100253 # /usr/include/GL/glu.h:130
GLU_NURBS_ERROR4 = 100254 # /usr/include/GL/glu.h:131
GLU_NURBS_ERROR5 = 100255 # /usr/include/GL/glu.h:132
GLU_NURBS_ERROR6 = 100256 # /usr/include/GL/glu.h:133
GLU_NURBS_ERROR7 = 100257 # /usr/include/GL/glu.h:134
GLU_NURBS_ERROR8 = 100258 # /usr/include/GL/glu.h:135
GLU_NURBS_ERROR9 = 100259 # /usr/include/GL/glu.h:136
GLU_NURBS_ERROR10 = 100260 # /usr/include/GL/glu.h:137
GLU_NURBS_ERROR11 = 100261 # /usr/include/GL/glu.h:138
GLU_NURBS_ERROR12 = 100262 # /usr/include/GL/glu.h:139
GLU_NURBS_ERROR13 = 100263 # /usr/include/GL/glu.h:140
GLU_NURBS_ERROR14 = 100264 # /usr/include/GL/glu.h:141
GLU_NURBS_ERROR15 = 100265 # /usr/include/GL/glu.h:142
GLU_NURBS_ERROR16 = 100266 # /usr/include/GL/glu.h:143
GLU_NURBS_ERROR17 = 100267 # /usr/include/GL/glu.h:144
GLU_NURBS_ERROR18 = 100268 # /usr/include/GL/glu.h:145
GLU_NURBS_ERROR19 = 100269 # /usr/include/GL/glu.h:146
GLU_NURBS_ERROR20 = 100270 # /usr/include/GL/glu.h:147
GLU_NURBS_ERROR21 = 100271 # /usr/include/GL/glu.h:148
GLU_NURBS_ERROR22 = 100272 # /usr/include/GL/glu.h:149
GLU_NURBS_ERROR23 = 100273 # /usr/include/GL/glu.h:150
GLU_NURBS_ERROR24 = 100274 # /usr/include/GL/glu.h:151
GLU_NURBS_ERROR25 = 100275 # /usr/include/GL/glu.h:152
GLU_NURBS_ERROR26 = 100276 # /usr/include/GL/glu.h:153
GLU_NURBS_ERROR27 = 100277 # /usr/include/GL/glu.h:154
GLU_NURBS_ERROR28 = 100278 # /usr/include/GL/glu.h:155
GLU_NURBS_ERROR29 = 100279 # /usr/include/GL/glu.h:156
GLU_NURBS_ERROR30 = 100280 # /usr/include/GL/glu.h:157
GLU_NURBS_ERROR31 = 100281 # /usr/include/GL/glu.h:158
GLU_NURBS_ERROR32 = 100282 # /usr/include/GL/glu.h:159
GLU_NURBS_ERROR33 = 100283 # /usr/include/GL/glu.h:160
GLU_NURBS_ERROR34 = 100284 # /usr/include/GL/glu.h:161
GLU_NURBS_ERROR35 = 100285 # /usr/include/GL/glu.h:162
GLU_NURBS_ERROR36 = 100286 # /usr/include/GL/glu.h:163
GLU_NURBS_ERROR37 = 100287 # /usr/include/GL/glu.h:164
GLU_AUTO_LOAD_MATRIX = 100200 # /usr/include/GL/glu.h:167
GLU_CULLING = 100201 # /usr/include/GL/glu.h:168
GLU_SAMPLING_TOLERANCE = 100203 # /usr/include/GL/glu.h:169
GLU_DISPLAY_MODE = 100204 # /usr/include/GL/glu.h:170
GLU_PARAMETRIC_TOLERANCE = 100202 # /usr/include/GL/glu.h:171
GLU_SAMPLING_METHOD = 100205 # /usr/include/GL/glu.h:172
GLU_U_STEP = 100206 # /usr/include/GL/glu.h:173
GLU_V_STEP = 100207 # /usr/include/GL/glu.h:174
GLU_NURBS_MODE = 100160 # /usr/include/GL/glu.h:175
GLU_NURBS_MODE_EXT = 100160 # /usr/include/GL/glu.h:176
GLU_NURBS_TESSELLATOR = 100161 # /usr/include/GL/glu.h:177
GLU_NURBS_TESSELLATOR_EXT = 100161 # /usr/include/GL/glu.h:178
GLU_NURBS_RENDERER = 100162 # /usr/include/GL/glu.h:179
GLU_NURBS_RENDERER_EXT = 100162 # /usr/include/GL/glu.h:180
GLU_OBJECT_PARAMETRIC_ERROR = 100208 # /usr/include/GL/glu.h:183
GLU_OBJECT_PARAMETRIC_ERROR_EXT = 100208 # /usr/include/GL/glu.h:184
GLU_OBJECT_PATH_LENGTH = 100209 # /usr/include/GL/glu.h:185
GLU_OBJECT_PATH_LENGTH_EXT = 100209 # /usr/include/GL/glu.h:186
GLU_PATH_LENGTH = 100215 # /usr/include/GL/glu.h:187
GLU_PARAMETRIC_ERROR = 100216 # /usr/include/GL/glu.h:188
GLU_DOMAIN_DISTANCE = 100217 # /usr/include/GL/glu.h:189
GLU_MAP1_TRIM_2 = 100210 # /usr/include/GL/glu.h:192
GLU_MAP1_TRIM_3 = 100211 # /usr/include/GL/glu.h:193
GLU_POINT = 100010 # /usr/include/GL/glu.h:196
GLU_LINE = 100011 # /usr/include/GL/glu.h:197
GLU_FILL = 100012 # /usr/include/GL/glu.h:198
GLU_SILHOUETTE = 100013 # /usr/include/GL/glu.h:199
GLU_SMOOTH = 100000 # /usr/include/GL/glu.h:205
GLU_FLAT = 100001 # /usr/include/GL/glu.h:206
GLU_NONE = 100002 # /usr/include/GL/glu.h:207
GLU_OUTSIDE = 100020 # /usr/include/GL/glu.h:210
GLU_INSIDE = 100021 # /usr/include/GL/glu.h:211
GLU_TESS_BEGIN = 100100 # /usr/include/GL/glu.h:214
GLU_BEGIN = 100100 # /usr/include/GL/glu.h:215
GLU_TESS_VERTEX = 100101 # /usr/include/GL/glu.h:216
GLU_VERTEX = 100101 # /usr/include/GL/glu.h:217
GLU_TESS_END = 100102 # /usr/include/GL/glu.h:218
GLU_END = 100102 # /usr/include/GL/glu.h:219
GLU_TESS_ERROR = 100103 # /usr/include/GL/glu.h:220
GLU_TESS_EDGE_FLAG = 100104 # /usr/include/GL/glu.h:221
GLU_EDGE_FLAG = 100104 # /usr/include/GL/glu.h:222
GLU_TESS_COMBINE = 100105 # /usr/include/GL/glu.h:223
GLU_TESS_BEGIN_DATA = 100106 # /usr/include/GL/glu.h:224
GLU_TESS_VERTEX_DATA = 100107 # /usr/include/GL/glu.h:225
GLU_TESS_END_DATA = 100108 # /usr/include/GL/glu.h:226
GLU_TESS_ERROR_DATA = 100109 # /usr/include/GL/glu.h:227
GLU_TESS_EDGE_FLAG_DATA = 100110 # /usr/include/GL/glu.h:228
GLU_TESS_COMBINE_DATA = 100111 # /usr/include/GL/glu.h:229
GLU_CW = 100120 # /usr/include/GL/glu.h:232
GLU_CCW = 100121 # /usr/include/GL/glu.h:233
GLU_INTERIOR = 100122 # /usr/include/GL/glu.h:234
GLU_EXTERIOR = 100123 # /usr/include/GL/glu.h:235
GLU_UNKNOWN = 100124 # /usr/include/GL/glu.h:236
GLU_TESS_WINDING_RULE = 100140 # /usr/include/GL/glu.h:239
GLU_TESS_BOUNDARY_ONLY = 100141 # /usr/include/GL/glu.h:240
GLU_TESS_TOLERANCE = 100142 # /usr/include/GL/glu.h:241
GLU_TESS_ERROR1 = 100151 # /usr/include/GL/glu.h:244
GLU_TESS_ERROR2 = 100152 # /usr/include/GL/glu.h:245
GLU_TESS_ERROR3 = 100153 # /usr/include/GL/glu.h:246
GLU_TESS_ERROR4 = 100154 # /usr/include/GL/glu.h:247
GLU_TESS_ERROR5 = 100155 # /usr/include/GL/glu.h:248
GLU_TESS_ERROR6 = 100156 # /usr/include/GL/glu.h:249
GLU_TESS_ERROR7 = 100157 # /usr/include/GL/glu.h:250
GLU_TESS_ERROR8 = 100158 # /usr/include/GL/glu.h:251
GLU_TESS_MISSING_BEGIN_POLYGON = 100151 # /usr/include/GL/glu.h:252
GLU_TESS_MISSING_BEGIN_CONTOUR = 100152 # /usr/include/GL/glu.h:253
GLU_TESS_MISSING_END_POLYGON = 100153 # /usr/include/GL/glu.h:254
GLU_TESS_MISSING_END_CONTOUR = 100154 # /usr/include/GL/glu.h:255
GLU_TESS_COORD_TOO_LARGE = 100155 # /usr/include/GL/glu.h:256
GLU_TESS_NEED_COMBINE_CALLBACK = 100156 # /usr/include/GL/glu.h:257
GLU_TESS_WINDING_ODD = 100130 # /usr/include/GL/glu.h:260
GLU_TESS_WINDING_NONZERO = 100131 # /usr/include/GL/glu.h:261
GLU_TESS_WINDING_POSITIVE = 100132 # /usr/include/GL/glu.h:262
GLU_TESS_WINDING_NEGATIVE = 100133 # /usr/include/GL/glu.h:263
GLU_TESS_WINDING_ABS_GEQ_TWO = 100134 # /usr/include/GL/glu.h:264
class struct_GLUnurbs(Structure):
__slots__ = [
]
struct_GLUnurbs._fields_ = [
('_opaque_struct', c_int)
]
class struct_GLUnurbs(Structure):
__slots__ = [
]
struct_GLUnurbs._fields_ = [
('_opaque_struct', c_int)
]
GLUnurbs = struct_GLUnurbs # /usr/include/GL/glu.h:274
class struct_GLUquadric(Structure):
__slots__ = [
]
struct_GLUquadric._fields_ = [
('_opaque_struct', c_int)
]
class struct_GLUquadric(Structure):
__slots__ = [
]
struct_GLUquadric._fields_ = [
('_opaque_struct', c_int)
]
GLUquadric = struct_GLUquadric # /usr/include/GL/glu.h:275
class struct_GLUtesselator(Structure):
__slots__ = [
]
struct_GLUtesselator._fields_ = [
('_opaque_struct', c_int)
]
class struct_GLUtesselator(Structure):
__slots__ = [
]
struct_GLUtesselator._fields_ = [
('_opaque_struct', c_int)
]
GLUtesselator = struct_GLUtesselator # /usr/include/GL/glu.h:276
GLUnurbsObj = GLUnurbs # /usr/include/GL/glu.h:279
GLUquadricObj = GLUquadric # /usr/include/GL/glu.h:280
GLUtesselatorObj = GLUtesselator # /usr/include/GL/glu.h:281
GLUtriangulatorObj = GLUtesselator # /usr/include/GL/glu.h:282
GLU_TESS_MAX_COORD = 9.9999999999999998e+149 # /usr/include/GL/glu.h:284
_GLUfuncptr = CFUNCTYPE(None) # /usr/include/GL/glu.h:287
# /usr/include/GL/glu.h:289
gluBeginCurve = _link_function('gluBeginCurve', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:290
gluBeginPolygon = _link_function('gluBeginPolygon', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:291
gluBeginSurface = _link_function('gluBeginSurface', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:292
gluBeginTrim = _link_function('gluBeginTrim', None, [POINTER(GLUnurbs)], None)
GLint = c_int # /usr/include/GL/gl.h:159
GLenum = c_uint # /usr/include/GL/gl.h:153
GLsizei = c_int # /usr/include/GL/gl.h:163
# /usr/include/GL/glu.h:293
gluBuild1DMipmapLevels = _link_function('gluBuild1DMipmapLevels', GLint, [GLenum, GLint, GLsizei, GLenum, GLenum, GLint, GLint, GLint, POINTER(None)], None)
# /usr/include/GL/glu.h:294
gluBuild1DMipmaps = _link_function('gluBuild1DMipmaps', GLint, [GLenum, GLint, GLsizei, GLenum, GLenum, POINTER(None)], None)
# /usr/include/GL/glu.h:295
gluBuild2DMipmapLevels = _link_function('gluBuild2DMipmapLevels', GLint, [GLenum, GLint, GLsizei, GLsizei, GLenum, GLenum, GLint, GLint, GLint, POINTER(None)], None)
# /usr/include/GL/glu.h:296
gluBuild2DMipmaps = _link_function('gluBuild2DMipmaps', GLint, [GLenum, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(None)], None)
# /usr/include/GL/glu.h:297
gluBuild3DMipmapLevels = _link_function('gluBuild3DMipmapLevels', GLint, [GLenum, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLint, GLint, GLint, POINTER(None)], None)
# /usr/include/GL/glu.h:298
gluBuild3DMipmaps = _link_function('gluBuild3DMipmaps', GLint, [GLenum, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(None)], None)
GLboolean = c_ubyte # /usr/include/GL/gl.h:154
GLubyte = c_ubyte # /usr/include/GL/gl.h:160
# /usr/include/GL/glu.h:299
gluCheckExtension = _link_function('gluCheckExtension', GLboolean, [POINTER(GLubyte), POINTER(GLubyte)], None)
GLdouble = c_double # /usr/include/GL/gl.h:166
# /usr/include/GL/glu.h:300
gluCylinder = _link_function('gluCylinder', None, [POINTER(GLUquadric), GLdouble, GLdouble, GLdouble, GLint, GLint], None)
# /usr/include/GL/glu.h:301
gluDeleteNurbsRenderer = _link_function('gluDeleteNurbsRenderer', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:302
gluDeleteQuadric = _link_function('gluDeleteQuadric', None, [POINTER(GLUquadric)], None)
# /usr/include/GL/glu.h:303
gluDeleteTess = _link_function('gluDeleteTess', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:304
gluDisk = _link_function('gluDisk', None, [POINTER(GLUquadric), GLdouble, GLdouble, GLint, GLint], None)
# /usr/include/GL/glu.h:305
gluEndCurve = _link_function('gluEndCurve', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:306
gluEndPolygon = _link_function('gluEndPolygon', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:307
gluEndSurface = _link_function('gluEndSurface', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:308
gluEndTrim = _link_function('gluEndTrim', None, [POINTER(GLUnurbs)], None)
# /usr/include/GL/glu.h:309
gluErrorString = _link_function('gluErrorString', POINTER(GLubyte), [GLenum], None)
GLfloat = c_float # /usr/include/GL/gl.h:164
# /usr/include/GL/glu.h:310
gluGetNurbsProperty = _link_function('gluGetNurbsProperty', None, [POINTER(GLUnurbs), GLenum, POINTER(GLfloat)], None)
# /usr/include/GL/glu.h:311
gluGetString = _link_function('gluGetString', POINTER(GLubyte), [GLenum], None)
# /usr/include/GL/glu.h:312
gluGetTessProperty = _link_function('gluGetTessProperty', None, [POINTER(GLUtesselator), GLenum, POINTER(GLdouble)], None)
# /usr/include/GL/glu.h:313
gluLoadSamplingMatrices = _link_function('gluLoadSamplingMatrices', None, [POINTER(GLUnurbs), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLint)], None)
# /usr/include/GL/glu.h:314
gluLookAt = _link_function('gluLookAt', None, [GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/glu.h:315
gluNewNurbsRenderer = _link_function('gluNewNurbsRenderer', POINTER(GLUnurbs), [], None)
# /usr/include/GL/glu.h:316
gluNewQuadric = _link_function('gluNewQuadric', POINTER(GLUquadric), [], None)
# /usr/include/GL/glu.h:317
gluNewTess = _link_function('gluNewTess', POINTER(GLUtesselator), [], None)
# /usr/include/GL/glu.h:318
gluNextContour = _link_function('gluNextContour', None, [POINTER(GLUtesselator), GLenum], None)
# /usr/include/GL/glu.h:319
gluNurbsCallback = _link_function('gluNurbsCallback', None, [POINTER(GLUnurbs), GLenum, _GLUfuncptr], None)
GLvoid = None # /usr/include/GL/gl.h:156
# /usr/include/GL/glu.h:320
gluNurbsCallbackData = _link_function('gluNurbsCallbackData', None, [POINTER(GLUnurbs), POINTER(GLvoid)], None)
# /usr/include/GL/glu.h:321
gluNurbsCallbackDataEXT = _link_function('gluNurbsCallbackDataEXT', None, [POINTER(GLUnurbs), POINTER(GLvoid)], None)
# /usr/include/GL/glu.h:322
gluNurbsCurve = _link_function('gluNurbsCurve', None, [POINTER(GLUnurbs), GLint, POINTER(GLfloat), GLint, POINTER(GLfloat), GLint, GLenum], None)
# /usr/include/GL/glu.h:323
gluNurbsProperty = _link_function('gluNurbsProperty', None, [POINTER(GLUnurbs), GLenum, GLfloat], None)
# /usr/include/GL/glu.h:324
gluNurbsSurface = _link_function('gluNurbsSurface', None, [POINTER(GLUnurbs), GLint, POINTER(GLfloat), GLint, POINTER(GLfloat), GLint, GLint, POINTER(GLfloat), GLint, GLint, GLenum], None)
# /usr/include/GL/glu.h:325
gluOrtho2D = _link_function('gluOrtho2D', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/glu.h:326
gluPartialDisk = _link_function('gluPartialDisk', None, [POINTER(GLUquadric), GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble], None)
# /usr/include/GL/glu.h:327
gluPerspective = _link_function('gluPerspective', None, [GLdouble, GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/glu.h:328
gluPickMatrix = _link_function('gluPickMatrix', None, [GLdouble, GLdouble, GLdouble, GLdouble, POINTER(GLint)], None)
# /usr/include/GL/glu.h:329
gluProject = _link_function('gluProject', GLint, [GLdouble, GLdouble, GLdouble, POINTER(GLdouble), POINTER(GLdouble), POINTER(GLint), POINTER(GLdouble), POINTER(GLdouble), POINTER(GLdouble)], None)
# /usr/include/GL/glu.h:330
gluPwlCurve = _link_function('gluPwlCurve', None, [POINTER(GLUnurbs), GLint, POINTER(GLfloat), GLint, GLenum], None)
# /usr/include/GL/glu.h:331
gluQuadricCallback = _link_function('gluQuadricCallback', None, [POINTER(GLUquadric), GLenum, _GLUfuncptr], None)
# /usr/include/GL/glu.h:332
gluQuadricDrawStyle = _link_function('gluQuadricDrawStyle', None, [POINTER(GLUquadric), GLenum], None)
# /usr/include/GL/glu.h:333
gluQuadricNormals = _link_function('gluQuadricNormals', None, [POINTER(GLUquadric), GLenum], None)
# /usr/include/GL/glu.h:334
gluQuadricOrientation = _link_function('gluQuadricOrientation', None, [POINTER(GLUquadric), GLenum], None)
# /usr/include/GL/glu.h:335
gluQuadricTexture = _link_function('gluQuadricTexture', None, [POINTER(GLUquadric), GLboolean], None)
# /usr/include/GL/glu.h:336
gluScaleImage = _link_function('gluScaleImage', GLint, [GLenum, GLsizei, GLsizei, GLenum, POINTER(None), GLsizei, GLsizei, GLenum, POINTER(GLvoid)], None)
# /usr/include/GL/glu.h:337
gluSphere = _link_function('gluSphere', None, [POINTER(GLUquadric), GLdouble, GLint, GLint], None)
# /usr/include/GL/glu.h:338
gluTessBeginContour = _link_function('gluTessBeginContour', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:339
gluTessBeginPolygon = _link_function('gluTessBeginPolygon', None, [POINTER(GLUtesselator), POINTER(GLvoid)], None)
# /usr/include/GL/glu.h:340
gluTessCallback = _link_function('gluTessCallback', None, [POINTER(GLUtesselator), GLenum, _GLUfuncptr], None)
# /usr/include/GL/glu.h:341
gluTessEndContour = _link_function('gluTessEndContour', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:342
gluTessEndPolygon = _link_function('gluTessEndPolygon', None, [POINTER(GLUtesselator)], None)
# /usr/include/GL/glu.h:343
gluTessNormal = _link_function('gluTessNormal', None, [POINTER(GLUtesselator), GLdouble, GLdouble, GLdouble], None)
# /usr/include/GL/glu.h:344
gluTessProperty = _link_function('gluTessProperty', None, [POINTER(GLUtesselator), GLenum, GLdouble], None)
# /usr/include/GL/glu.h:345
gluTessVertex = _link_function('gluTessVertex', None, [POINTER(GLUtesselator), POINTER(GLdouble), POINTER(GLvoid)], None)
# /usr/include/GL/glu.h:346
gluUnProject = _link_function('gluUnProject', GLint, [GLdouble, GLdouble, GLdouble, POINTER(GLdouble), POINTER(GLdouble), POINTER(GLint), POINTER(GLdouble), POINTER(GLdouble), POINTER(GLdouble)], None)
# /usr/include/GL/glu.h:347
gluUnProject4 = _link_function('gluUnProject4', GLint, [GLdouble, GLdouble, GLdouble, GLdouble, POINTER(GLdouble), POINTER(GLdouble), POINTER(GLint), GLdouble, GLdouble, POINTER(GLdouble), POINTER(GLdouble), POINTER(GLdouble), POINTER(GLdouble)], None)
__all__ = ['GLU_EXT_object_space_tess', 'GLU_EXT_nurbs_tessellator',
'GLU_FALSE', 'GLU_TRUE', 'GLU_VERSION_1_1', 'GLU_VERSION_1_2',
'GLU_VERSION_1_3', 'GLU_VERSION', 'GLU_EXTENSIONS', 'GLU_INVALID_ENUM',
'GLU_INVALID_VALUE', 'GLU_OUT_OF_MEMORY', 'GLU_INCOMPATIBLE_GL_VERSION',
'GLU_INVALID_OPERATION', 'GLU_OUTLINE_POLYGON', 'GLU_OUTLINE_PATCH',
'GLU_NURBS_ERROR', 'GLU_ERROR', 'GLU_NURBS_BEGIN', 'GLU_NURBS_BEGIN_EXT',
'GLU_NURBS_VERTEX', 'GLU_NURBS_VERTEX_EXT', 'GLU_NURBS_NORMAL',
'GLU_NURBS_NORMAL_EXT', 'GLU_NURBS_COLOR', 'GLU_NURBS_COLOR_EXT',
'GLU_NURBS_TEXTURE_COORD', 'GLU_NURBS_TEX_COORD_EXT', 'GLU_NURBS_END',
'GLU_NURBS_END_EXT', 'GLU_NURBS_BEGIN_DATA', 'GLU_NURBS_BEGIN_DATA_EXT',
'GLU_NURBS_VERTEX_DATA', 'GLU_NURBS_VERTEX_DATA_EXT', 'GLU_NURBS_NORMAL_DATA',
'GLU_NURBS_NORMAL_DATA_EXT', 'GLU_NURBS_COLOR_DATA',
'GLU_NURBS_COLOR_DATA_EXT', 'GLU_NURBS_TEXTURE_COORD_DATA',
'GLU_NURBS_TEX_COORD_DATA_EXT', 'GLU_NURBS_END_DATA',
'GLU_NURBS_END_DATA_EXT', 'GLU_NURBS_ERROR1', 'GLU_NURBS_ERROR2',
'GLU_NURBS_ERROR3', 'GLU_NURBS_ERROR4', 'GLU_NURBS_ERROR5',
'GLU_NURBS_ERROR6', 'GLU_NURBS_ERROR7', 'GLU_NURBS_ERROR8',
'GLU_NURBS_ERROR9', 'GLU_NURBS_ERROR10', 'GLU_NURBS_ERROR11',
'GLU_NURBS_ERROR12', 'GLU_NURBS_ERROR13', 'GLU_NURBS_ERROR14',
'GLU_NURBS_ERROR15', 'GLU_NURBS_ERROR16', 'GLU_NURBS_ERROR17',
'GLU_NURBS_ERROR18', 'GLU_NURBS_ERROR19', 'GLU_NURBS_ERROR20',
'GLU_NURBS_ERROR21', 'GLU_NURBS_ERROR22', 'GLU_NURBS_ERROR23',
'GLU_NURBS_ERROR24', 'GLU_NURBS_ERROR25', 'GLU_NURBS_ERROR26',
'GLU_NURBS_ERROR27', 'GLU_NURBS_ERROR28', 'GLU_NURBS_ERROR29',
'GLU_NURBS_ERROR30', 'GLU_NURBS_ERROR31', 'GLU_NURBS_ERROR32',
'GLU_NURBS_ERROR33', 'GLU_NURBS_ERROR34', 'GLU_NURBS_ERROR35',
'GLU_NURBS_ERROR36', 'GLU_NURBS_ERROR37', 'GLU_AUTO_LOAD_MATRIX',
'GLU_CULLING', 'GLU_SAMPLING_TOLERANCE', 'GLU_DISPLAY_MODE',
'GLU_PARAMETRIC_TOLERANCE', 'GLU_SAMPLING_METHOD', 'GLU_U_STEP', 'GLU_V_STEP',
'GLU_NURBS_MODE', 'GLU_NURBS_MODE_EXT', 'GLU_NURBS_TESSELLATOR',
'GLU_NURBS_TESSELLATOR_EXT', 'GLU_NURBS_RENDERER', 'GLU_NURBS_RENDERER_EXT',
'GLU_OBJECT_PARAMETRIC_ERROR', 'GLU_OBJECT_PARAMETRIC_ERROR_EXT',
'GLU_OBJECT_PATH_LENGTH', 'GLU_OBJECT_PATH_LENGTH_EXT', 'GLU_PATH_LENGTH',
'GLU_PARAMETRIC_ERROR', 'GLU_DOMAIN_DISTANCE', 'GLU_MAP1_TRIM_2',
'GLU_MAP1_TRIM_3', 'GLU_POINT', 'GLU_LINE', 'GLU_FILL', 'GLU_SILHOUETTE',
'GLU_SMOOTH', 'GLU_FLAT', 'GLU_NONE', 'GLU_OUTSIDE', 'GLU_INSIDE',
'GLU_TESS_BEGIN', 'GLU_BEGIN', 'GLU_TESS_VERTEX', 'GLU_VERTEX',
'GLU_TESS_END', 'GLU_END', 'GLU_TESS_ERROR', 'GLU_TESS_EDGE_FLAG',
'GLU_EDGE_FLAG', 'GLU_TESS_COMBINE', 'GLU_TESS_BEGIN_DATA',
'GLU_TESS_VERTEX_DATA', 'GLU_TESS_END_DATA', 'GLU_TESS_ERROR_DATA',
'GLU_TESS_EDGE_FLAG_DATA', 'GLU_TESS_COMBINE_DATA', 'GLU_CW', 'GLU_CCW',
'GLU_INTERIOR', 'GLU_EXTERIOR', 'GLU_UNKNOWN', 'GLU_TESS_WINDING_RULE',
'GLU_TESS_BOUNDARY_ONLY', 'GLU_TESS_TOLERANCE', 'GLU_TESS_ERROR1',
'GLU_TESS_ERROR2', 'GLU_TESS_ERROR3', 'GLU_TESS_ERROR4', 'GLU_TESS_ERROR5',
'GLU_TESS_ERROR6', 'GLU_TESS_ERROR7', 'GLU_TESS_ERROR8',
'GLU_TESS_MISSING_BEGIN_POLYGON', 'GLU_TESS_MISSING_BEGIN_CONTOUR',
'GLU_TESS_MISSING_END_POLYGON', 'GLU_TESS_MISSING_END_CONTOUR',
'GLU_TESS_COORD_TOO_LARGE', 'GLU_TESS_NEED_COMBINE_CALLBACK',
'GLU_TESS_WINDING_ODD', 'GLU_TESS_WINDING_NONZERO',
'GLU_TESS_WINDING_POSITIVE', 'GLU_TESS_WINDING_NEGATIVE',
'GLU_TESS_WINDING_ABS_GEQ_TWO', 'GLUnurbs', 'GLUquadric', 'GLUtesselator',
'GLUnurbsObj', 'GLUquadricObj', 'GLUtesselatorObj', 'GLUtriangulatorObj',
'GLU_TESS_MAX_COORD', '_GLUfuncptr', 'gluBeginCurve', 'gluBeginPolygon',
'gluBeginSurface', 'gluBeginTrim', 'gluBuild1DMipmapLevels',
'gluBuild1DMipmaps', 'gluBuild2DMipmapLevels', 'gluBuild2DMipmaps',
'gluBuild3DMipmapLevels', 'gluBuild3DMipmaps', 'gluCheckExtension',
'gluCylinder', 'gluDeleteNurbsRenderer', 'gluDeleteQuadric', 'gluDeleteTess',
'gluDisk', 'gluEndCurve', 'gluEndPolygon', 'gluEndSurface', 'gluEndTrim',
'gluErrorString', 'gluGetNurbsProperty', 'gluGetString', 'gluGetTessProperty',
'gluLoadSamplingMatrices', 'gluLookAt', 'gluNewNurbsRenderer',
'gluNewQuadric', 'gluNewTess', 'gluNextContour', 'gluNurbsCallback',
'gluNurbsCallbackData', 'gluNurbsCallbackDataEXT', 'gluNurbsCurve',
'gluNurbsProperty', 'gluNurbsSurface', 'gluOrtho2D', 'gluPartialDisk',
'gluPerspective', 'gluPickMatrix', 'gluProject', 'gluPwlCurve',
'gluQuadricCallback', 'gluQuadricDrawStyle', 'gluQuadricNormals',
'gluQuadricOrientation', 'gluQuadricTexture', 'gluScaleImage', 'gluSphere',
'gluTessBeginContour', 'gluTessBeginPolygon', 'gluTessCallback',
'gluTessEndContour', 'gluTessEndPolygon', 'gluTessNormal', 'gluTessProperty',
'gluTessVertex', 'gluUnProject', 'gluUnProject4']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''OpenGL and GLU interface.
This package imports all OpenGL, GLU and registered OpenGL extension
functions. Functions have identical signatures to their C counterparts. For
example::
from pyglet.gl import *
# [...omitted: set up a GL context and framebuffer]
glBegin(GL_QUADS)
glVertex3f(0, 0, 0)
glVertex3f(0.1, 0.2, 0.3)
glVertex3f(0.1, 0.2, 0.3)
glEnd()
OpenGL is documented in full at the `OpenGL Reference Pages`_.
The `OpenGL Programming Guide`_ is a popular reference manual organised by
topic. The free online version documents only OpenGL 1.1. `Later editions`_
cover more recent versions of the API and can be purchased from a book store.
.. _OpenGL Reference Pages: http://www.opengl.org/documentation/red_book/
.. _OpenGL Programming Guide: http://fly.cc.fer.hr/~unreal/theredbook/
.. _Later editions: http://www.opengl.org/documentation/red_book/
The following subpackages are imported into this "mega" package already (and
so are available by importing ``pyglet.gl``):
``pyglet.gl.gl``
OpenGL
``pyglet.gl.glu``
GLU
``pyglet.gl.gl.glext_arb``
ARB registered OpenGL extension functions
These subpackages are also available, but are not imported into this namespace
by default:
``pyglet.gl.glext_nv``
nVidia OpenGL extension functions
``pyglet.gl.agl``
AGL (Mac OS X OpenGL context functions)
``pyglet.gl.glx``
GLX (Linux OpenGL context functions)
``pyglet.gl.glxext_arb``
ARB registered GLX extension functions
``pyglet.gl.glxext_nv``
nvidia GLX extension functions
``pyglet.gl.wgl``
WGL (Windows OpenGL context functions)
``pyglet.gl.wglext_arb``
ARB registered WGL extension functions
``pyglet.gl.wglext_nv``
nvidia WGL extension functions
The information modules are provided for convenience, and are documented
below.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from pyglet.gl.lib import GLException
from pyglet.gl.gl import *
from pyglet.gl.glu import *
from pyglet.gl.glext_arb import *
from pyglet.gl import gl_info
import sys as _sys
_is_epydoc = hasattr(_sys, 'is_epydoc') and _sys.is_epydoc
#: The active OpenGL context.
#:
#: You can change the current context by calling `Context.set_current`; do not
#: modify this global.
#:
#: :type: `Context`
#:
#: :since: pyglet 1.1
current_context = None
def get_current_context():
'''Return the active OpenGL context.
You can change the current context by calling `Context.set_current`.
:deprecated: Use `current_context`
:rtype: `Context`
:return: the context to which OpenGL commands are directed, or None
if there is no selected context.
'''
return current_context
class ContextException(Exception):
pass
class ConfigException(Exception):
pass
import pyglet as _pyglet
if _pyglet.options['debug_texture']:
_debug_texture_total = 0
_debug_texture_sizes = {}
_debug_texture = None
def _debug_texture_alloc(texture, size):
global _debug_texture_total
_debug_texture_sizes[texture] = size
_debug_texture_total += size
print '%d (+%d)' % (_debug_texture_total, size)
def _debug_texture_dealloc(texture):
global _debug_texture_total
size = _debug_texture_sizes[texture]
del _debug_texture_sizes[texture]
_debug_texture_total -= size
print '%d (-%d)' % (_debug_texture_total, size)
_glBindTexture = glBindTexture
def glBindTexture(target, texture):
global _debug_texture
_debug_texture = texture
return _glBindTexture(target, texture)
_glTexImage2D = glTexImage2D
def glTexImage2D(target, level, internalformat, width, height, border,
format, type, pixels):
try:
_debug_texture_dealloc(_debug_texture)
except KeyError:
pass
if internalformat in (1, GL_ALPHA, GL_INTENSITY, GL_LUMINANCE):
depth = 1
elif internalformat in (2, GL_RGB16, GL_RGBA16):
depth = 2
elif internalformat in (3, GL_RGB):
depth = 3
else:
depth = 4 # Pretty crap assumption
size = (width + 2 * border) * (height + 2 * border) * depth
_debug_texture_alloc(_debug_texture, size)
return _glTexImage2D(target, level, internalformat, width, height,
border, format, type, pixels)
_glDeleteTextures = glDeleteTextures
def glDeleteTextures(n, textures):
if not hasattr(textures, '__len__'):
_debug_texture_dealloc(textures.value)
else:
for i in range(n):
_debug_texture_dealloc(textures[i].value)
return _glDeleteTextures(n, textures)
def _create_shadow_window():
global _shadow_window
import pyglet
if not pyglet.options['shadow_window'] or _is_epydoc:
return
from pyglet.window import Window
_shadow_window = Window(width=1, height=1, visible=False)
_shadow_window.switch_to()
from pyglet import app
app.windows.remove(_shadow_window)
from pyglet import compat_platform
from base import ObjectSpace, CanvasConfig, Context
if _is_epydoc:
from base import Config
elif compat_platform in ('win32', 'cygwin'):
from win32 import Win32Config as Config
elif compat_platform.startswith('linux'):
from xlib import XlibConfig as Config
elif compat_platform == 'darwin':
if _pyglet.options['darwin_cocoa']:
from cocoa import CocoaConfig as Config
else:
from carbon import CarbonConfig as Config
del base
# XXX remove
_shadow_window = None
# Import pyglet.window now if it isn't currently being imported (this creates
# the shadow window).
if (not _is_epydoc and
'pyglet.window' not in _sys.modules and
_pyglet.options['shadow_window']):
# trickery is for circular import
_pyglet.gl = _sys.modules[__name__]
import pyglet.window
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://oss.sgi.com/projects/ogl-sample/ABI/glext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl.lib import link_GL as _link_function
from pyglet.gl.lib import c_ptrdiff_t
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by gengl.py.
# Wrapper for http://www.opengl.org/registry/api/glext.h
# ARB_multitexture (/usr/include/GL/gl.h:1962)
GL_GLEXT_VERSION = 82 # GL/glext.h:34
# VERSION_1_2 (GL/glext.h:54)
# VERSION_1_2_DEPRECATED (GL/glext.h:93)
GL_RESCALE_NORMAL = 32826 # GL/glext.h:94
GL_LIGHT_MODEL_COLOR_CONTROL = 33272 # GL/glext.h:95
GL_SINGLE_COLOR = 33273 # GL/glext.h:96
GL_SEPARATE_SPECULAR_COLOR = 33274 # GL/glext.h:97
GL_ALIASED_POINT_SIZE_RANGE = 33901 # GL/glext.h:98
# ARB_imaging (GL/glext.h:101)
# ARB_imaging_DEPRECATED (GL/glext.h:115)
GL_CONVOLUTION_1D = 32784 # GL/glext.h:116
GL_CONVOLUTION_2D = 32785 # GL/glext.h:117
GL_SEPARABLE_2D = 32786 # GL/glext.h:118
GL_CONVOLUTION_BORDER_MODE = 32787 # GL/glext.h:119
GL_CONVOLUTION_FILTER_SCALE = 32788 # GL/glext.h:120
GL_CONVOLUTION_FILTER_BIAS = 32789 # GL/glext.h:121
GL_REDUCE = 32790 # GL/glext.h:122
GL_CONVOLUTION_FORMAT = 32791 # GL/glext.h:123
GL_CONVOLUTION_WIDTH = 32792 # GL/glext.h:124
GL_CONVOLUTION_HEIGHT = 32793 # GL/glext.h:125
GL_MAX_CONVOLUTION_WIDTH = 32794 # GL/glext.h:126
GL_MAX_CONVOLUTION_HEIGHT = 32795 # GL/glext.h:127
GL_POST_CONVOLUTION_RED_SCALE = 32796 # GL/glext.h:128
GL_POST_CONVOLUTION_GREEN_SCALE = 32797 # GL/glext.h:129
GL_POST_CONVOLUTION_BLUE_SCALE = 32798 # GL/glext.h:130
GL_POST_CONVOLUTION_ALPHA_SCALE = 32799 # GL/glext.h:131
GL_POST_CONVOLUTION_RED_BIAS = 32800 # GL/glext.h:132
GL_POST_CONVOLUTION_GREEN_BIAS = 32801 # GL/glext.h:133
GL_POST_CONVOLUTION_BLUE_BIAS = 32802 # GL/glext.h:134
GL_POST_CONVOLUTION_ALPHA_BIAS = 32803 # GL/glext.h:135
GL_HISTOGRAM = 32804 # GL/glext.h:136
GL_PROXY_HISTOGRAM = 32805 # GL/glext.h:137
GL_HISTOGRAM_WIDTH = 32806 # GL/glext.h:138
GL_HISTOGRAM_FORMAT = 32807 # GL/glext.h:139
GL_HISTOGRAM_RED_SIZE = 32808 # GL/glext.h:140
GL_HISTOGRAM_GREEN_SIZE = 32809 # GL/glext.h:141
GL_HISTOGRAM_BLUE_SIZE = 32810 # GL/glext.h:142
GL_HISTOGRAM_ALPHA_SIZE = 32811 # GL/glext.h:143
GL_HISTOGRAM_LUMINANCE_SIZE = 32812 # GL/glext.h:144
GL_HISTOGRAM_SINK = 32813 # GL/glext.h:145
GL_MINMAX = 32814 # GL/glext.h:146
GL_MINMAX_FORMAT = 32815 # GL/glext.h:147
GL_MINMAX_SINK = 32816 # GL/glext.h:148
GL_TABLE_TOO_LARGE = 32817 # GL/glext.h:149
GL_COLOR_MATRIX = 32945 # GL/glext.h:150
GL_COLOR_MATRIX_STACK_DEPTH = 32946 # GL/glext.h:151
GL_MAX_COLOR_MATRIX_STACK_DEPTH = 32947 # GL/glext.h:152
GL_POST_COLOR_MATRIX_RED_SCALE = 32948 # GL/glext.h:153
GL_POST_COLOR_MATRIX_GREEN_SCALE = 32949 # GL/glext.h:154
GL_POST_COLOR_MATRIX_BLUE_SCALE = 32950 # GL/glext.h:155
GL_POST_COLOR_MATRIX_ALPHA_SCALE = 32951 # GL/glext.h:156
GL_POST_COLOR_MATRIX_RED_BIAS = 32952 # GL/glext.h:157
GL_POST_COLOR_MATRIX_GREEN_BIAS = 32953 # GL/glext.h:158
GL_POST_COLOR_MATRIX_BLUE_BIAS = 32954 # GL/glext.h:159
GL_POST_COLOR_MATRIX_ALPHA_BIAS = 32955 # GL/glext.h:160
GL_COLOR_TABLE = 32976 # GL/glext.h:161
GL_POST_CONVOLUTION_COLOR_TABLE = 32977 # GL/glext.h:162
GL_POST_COLOR_MATRIX_COLOR_TABLE = 32978 # GL/glext.h:163
GL_PROXY_COLOR_TABLE = 32979 # GL/glext.h:164
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 32980 # GL/glext.h:165
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 32981 # GL/glext.h:166
GL_COLOR_TABLE_SCALE = 32982 # GL/glext.h:167
GL_COLOR_TABLE_BIAS = 32983 # GL/glext.h:168
GL_COLOR_TABLE_FORMAT = 32984 # GL/glext.h:169
GL_COLOR_TABLE_WIDTH = 32985 # GL/glext.h:170
GL_COLOR_TABLE_RED_SIZE = 32986 # GL/glext.h:171
GL_COLOR_TABLE_GREEN_SIZE = 32987 # GL/glext.h:172
GL_COLOR_TABLE_BLUE_SIZE = 32988 # GL/glext.h:173
GL_COLOR_TABLE_ALPHA_SIZE = 32989 # GL/glext.h:174
GL_COLOR_TABLE_LUMINANCE_SIZE = 32990 # GL/glext.h:175
GL_COLOR_TABLE_INTENSITY_SIZE = 32991 # GL/glext.h:176
GL_CONSTANT_BORDER = 33105 # GL/glext.h:177
GL_REPLICATE_BORDER = 33107 # GL/glext.h:178
GL_CONVOLUTION_BORDER_COLOR = 33108 # GL/glext.h:179
# VERSION_1_3 (GL/glext.h:182)
# VERSION_1_3_DEPRECATED (GL/glext.h:244)
GL_CLIENT_ACTIVE_TEXTURE = 34017 # GL/glext.h:245
GL_MAX_TEXTURE_UNITS = 34018 # GL/glext.h:246
GL_TRANSPOSE_MODELVIEW_MATRIX = 34019 # GL/glext.h:247
GL_TRANSPOSE_PROJECTION_MATRIX = 34020 # GL/glext.h:248
GL_TRANSPOSE_TEXTURE_MATRIX = 34021 # GL/glext.h:249
GL_TRANSPOSE_COLOR_MATRIX = 34022 # GL/glext.h:250
GL_MULTISAMPLE_BIT = 536870912 # GL/glext.h:251
GL_NORMAL_MAP = 34065 # GL/glext.h:252
GL_REFLECTION_MAP = 34066 # GL/glext.h:253
GL_COMPRESSED_ALPHA = 34025 # GL/glext.h:254
GL_COMPRESSED_LUMINANCE = 34026 # GL/glext.h:255
GL_COMPRESSED_LUMINANCE_ALPHA = 34027 # GL/glext.h:256
GL_COMPRESSED_INTENSITY = 34028 # GL/glext.h:257
GL_COMBINE = 34160 # GL/glext.h:258
GL_COMBINE_RGB = 34161 # GL/glext.h:259
GL_COMBINE_ALPHA = 34162 # GL/glext.h:260
GL_SOURCE0_RGB = 34176 # GL/glext.h:261
GL_SOURCE1_RGB = 34177 # GL/glext.h:262
GL_SOURCE2_RGB = 34178 # GL/glext.h:263
GL_SOURCE0_ALPHA = 34184 # GL/glext.h:264
GL_SOURCE1_ALPHA = 34185 # GL/glext.h:265
GL_SOURCE2_ALPHA = 34186 # GL/glext.h:266
GL_OPERAND0_RGB = 34192 # GL/glext.h:267
GL_OPERAND1_RGB = 34193 # GL/glext.h:268
GL_OPERAND2_RGB = 34194 # GL/glext.h:269
GL_OPERAND0_ALPHA = 34200 # GL/glext.h:270
GL_OPERAND1_ALPHA = 34201 # GL/glext.h:271
GL_OPERAND2_ALPHA = 34202 # GL/glext.h:272
GL_RGB_SCALE = 34163 # GL/glext.h:273
GL_ADD_SIGNED = 34164 # GL/glext.h:274
GL_INTERPOLATE = 34165 # GL/glext.h:275
GL_SUBTRACT = 34023 # GL/glext.h:276
GL_CONSTANT = 34166 # GL/glext.h:277
GL_PRIMARY_COLOR = 34167 # GL/glext.h:278
GL_PREVIOUS = 34168 # GL/glext.h:279
GL_DOT3_RGB = 34478 # GL/glext.h:280
GL_DOT3_RGBA = 34479 # GL/glext.h:281
# VERSION_1_4 (GL/glext.h:284)
GL_BLEND_DST_RGB = 32968 # GL/glext.h:285
GL_BLEND_SRC_RGB = 32969 # GL/glext.h:286
GL_BLEND_DST_ALPHA = 32970 # GL/glext.h:287
GL_BLEND_SRC_ALPHA = 32971 # GL/glext.h:288
GL_POINT_FADE_THRESHOLD_SIZE = 33064 # GL/glext.h:289
GL_DEPTH_COMPONENT16 = 33189 # GL/glext.h:290
GL_DEPTH_COMPONENT24 = 33190 # GL/glext.h:291
GL_DEPTH_COMPONENT32 = 33191 # GL/glext.h:292
GL_MIRRORED_REPEAT = 33648 # GL/glext.h:293
GL_MAX_TEXTURE_LOD_BIAS = 34045 # GL/glext.h:294
GL_TEXTURE_LOD_BIAS = 34049 # GL/glext.h:295
GL_INCR_WRAP = 34055 # GL/glext.h:296
GL_DECR_WRAP = 34056 # GL/glext.h:297
GL_TEXTURE_DEPTH_SIZE = 34890 # GL/glext.h:298
GL_TEXTURE_COMPARE_MODE = 34892 # GL/glext.h:299
GL_TEXTURE_COMPARE_FUNC = 34893 # GL/glext.h:300
# VERSION_1_4_DEPRECATED (GL/glext.h:303)
GL_POINT_SIZE_MIN = 33062 # GL/glext.h:304
GL_POINT_SIZE_MAX = 33063 # GL/glext.h:305
GL_POINT_DISTANCE_ATTENUATION = 33065 # GL/glext.h:306
GL_GENERATE_MIPMAP = 33169 # GL/glext.h:307
GL_GENERATE_MIPMAP_HINT = 33170 # GL/glext.h:308
GL_FOG_COORDINATE_SOURCE = 33872 # GL/glext.h:309
GL_FOG_COORDINATE = 33873 # GL/glext.h:310
GL_FRAGMENT_DEPTH = 33874 # GL/glext.h:311
GL_CURRENT_FOG_COORDINATE = 33875 # GL/glext.h:312
GL_FOG_COORDINATE_ARRAY_TYPE = 33876 # GL/glext.h:313
GL_FOG_COORDINATE_ARRAY_STRIDE = 33877 # GL/glext.h:314
GL_FOG_COORDINATE_ARRAY_POINTER = 33878 # GL/glext.h:315
GL_FOG_COORDINATE_ARRAY = 33879 # GL/glext.h:316
GL_COLOR_SUM = 33880 # GL/glext.h:317
GL_CURRENT_SECONDARY_COLOR = 33881 # GL/glext.h:318
GL_SECONDARY_COLOR_ARRAY_SIZE = 33882 # GL/glext.h:319
GL_SECONDARY_COLOR_ARRAY_TYPE = 33883 # GL/glext.h:320
GL_SECONDARY_COLOR_ARRAY_STRIDE = 33884 # GL/glext.h:321
GL_SECONDARY_COLOR_ARRAY_POINTER = 33885 # GL/glext.h:322
GL_SECONDARY_COLOR_ARRAY = 33886 # GL/glext.h:323
GL_TEXTURE_FILTER_CONTROL = 34048 # GL/glext.h:324
GL_DEPTH_TEXTURE_MODE = 34891 # GL/glext.h:325
GL_COMPARE_R_TO_TEXTURE = 34894 # GL/glext.h:326
# VERSION_1_5 (GL/glext.h:329)
GL_BUFFER_SIZE = 34660 # GL/glext.h:330
GL_BUFFER_USAGE = 34661 # GL/glext.h:331
GL_QUERY_COUNTER_BITS = 34916 # GL/glext.h:332
GL_CURRENT_QUERY = 34917 # GL/glext.h:333
GL_QUERY_RESULT = 34918 # GL/glext.h:334
GL_QUERY_RESULT_AVAILABLE = 34919 # GL/glext.h:335
GL_ARRAY_BUFFER = 34962 # GL/glext.h:336
GL_ELEMENT_ARRAY_BUFFER = 34963 # GL/glext.h:337
GL_ARRAY_BUFFER_BINDING = 34964 # GL/glext.h:338
GL_ELEMENT_ARRAY_BUFFER_BINDING = 34965 # GL/glext.h:339
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 34975 # GL/glext.h:340
GL_READ_ONLY = 35000 # GL/glext.h:341
GL_WRITE_ONLY = 35001 # GL/glext.h:342
GL_READ_WRITE = 35002 # GL/glext.h:343
GL_BUFFER_ACCESS = 35003 # GL/glext.h:344
GL_BUFFER_MAPPED = 35004 # GL/glext.h:345
GL_BUFFER_MAP_POINTER = 35005 # GL/glext.h:346
GL_STREAM_DRAW = 35040 # GL/glext.h:347
GL_STREAM_READ = 35041 # GL/glext.h:348
GL_STREAM_COPY = 35042 # GL/glext.h:349
GL_STATIC_DRAW = 35044 # GL/glext.h:350
GL_STATIC_READ = 35045 # GL/glext.h:351
GL_STATIC_COPY = 35046 # GL/glext.h:352
GL_DYNAMIC_DRAW = 35048 # GL/glext.h:353
GL_DYNAMIC_READ = 35049 # GL/glext.h:354
GL_DYNAMIC_COPY = 35050 # GL/glext.h:355
GL_SAMPLES_PASSED = 35092 # GL/glext.h:356
# VERSION_1_5_DEPRECATED (GL/glext.h:359)
GL_VERTEX_ARRAY_BUFFER_BINDING = 34966 # GL/glext.h:360
GL_NORMAL_ARRAY_BUFFER_BINDING = 34967 # GL/glext.h:361
GL_COLOR_ARRAY_BUFFER_BINDING = 34968 # GL/glext.h:362
GL_INDEX_ARRAY_BUFFER_BINDING = 34969 # GL/glext.h:363
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 34970 # GL/glext.h:364
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 34971 # GL/glext.h:365
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 34972 # GL/glext.h:366
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 34973 # GL/glext.h:367
GL_WEIGHT_ARRAY_BUFFER_BINDING = 34974 # GL/glext.h:368
GL_FOG_COORD_SRC = 33872 # GL/glext.h:369
GL_FOG_COORD = 33873 # GL/glext.h:370
GL_CURRENT_FOG_COORD = 33875 # GL/glext.h:371
GL_FOG_COORD_ARRAY_TYPE = 33876 # GL/glext.h:372
GL_FOG_COORD_ARRAY_STRIDE = 33877 # GL/glext.h:373
GL_FOG_COORD_ARRAY_POINTER = 33878 # GL/glext.h:374
GL_FOG_COORD_ARRAY = 33879 # GL/glext.h:375
GL_FOG_COORD_ARRAY_BUFFER_BINDING = 34973 # GL/glext.h:376
GL_SRC0_RGB = 34176 # GL/glext.h:377
GL_SRC1_RGB = 34177 # GL/glext.h:378
GL_SRC2_RGB = 34178 # GL/glext.h:379
GL_SRC0_ALPHA = 34184 # GL/glext.h:380
GL_SRC1_ALPHA = 34185 # GL/glext.h:381
GL_SRC2_ALPHA = 34186 # GL/glext.h:382
# VERSION_2_0 (GL/glext.h:385)
GL_BLEND_EQUATION_RGB = 32777 # GL/glext.h:386
GL_VERTEX_ATTRIB_ARRAY_ENABLED = 34338 # GL/glext.h:387
GL_VERTEX_ATTRIB_ARRAY_SIZE = 34339 # GL/glext.h:388
GL_VERTEX_ATTRIB_ARRAY_STRIDE = 34340 # GL/glext.h:389
GL_VERTEX_ATTRIB_ARRAY_TYPE = 34341 # GL/glext.h:390
GL_CURRENT_VERTEX_ATTRIB = 34342 # GL/glext.h:391
GL_VERTEX_PROGRAM_POINT_SIZE = 34370 # GL/glext.h:392
GL_VERTEX_ATTRIB_ARRAY_POINTER = 34373 # GL/glext.h:393
GL_STENCIL_BACK_FUNC = 34816 # GL/glext.h:394
GL_STENCIL_BACK_FAIL = 34817 # GL/glext.h:395
GL_STENCIL_BACK_PASS_DEPTH_FAIL = 34818 # GL/glext.h:396
GL_STENCIL_BACK_PASS_DEPTH_PASS = 34819 # GL/glext.h:397
GL_MAX_DRAW_BUFFERS = 34852 # GL/glext.h:398
GL_DRAW_BUFFER0 = 34853 # GL/glext.h:399
GL_DRAW_BUFFER1 = 34854 # GL/glext.h:400
GL_DRAW_BUFFER2 = 34855 # GL/glext.h:401
GL_DRAW_BUFFER3 = 34856 # GL/glext.h:402
GL_DRAW_BUFFER4 = 34857 # GL/glext.h:403
GL_DRAW_BUFFER5 = 34858 # GL/glext.h:404
GL_DRAW_BUFFER6 = 34859 # GL/glext.h:405
GL_DRAW_BUFFER7 = 34860 # GL/glext.h:406
GL_DRAW_BUFFER8 = 34861 # GL/glext.h:407
GL_DRAW_BUFFER9 = 34862 # GL/glext.h:408
GL_DRAW_BUFFER10 = 34863 # GL/glext.h:409
GL_DRAW_BUFFER11 = 34864 # GL/glext.h:410
GL_DRAW_BUFFER12 = 34865 # GL/glext.h:411
GL_DRAW_BUFFER13 = 34866 # GL/glext.h:412
GL_DRAW_BUFFER14 = 34867 # GL/glext.h:413
GL_DRAW_BUFFER15 = 34868 # GL/glext.h:414
GL_BLEND_EQUATION_ALPHA = 34877 # GL/glext.h:415
GL_MAX_VERTEX_ATTRIBS = 34921 # GL/glext.h:416
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922 # GL/glext.h:417
GL_MAX_TEXTURE_IMAGE_UNITS = 34930 # GL/glext.h:418
GL_FRAGMENT_SHADER = 35632 # GL/glext.h:419
GL_VERTEX_SHADER = 35633 # GL/glext.h:420
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 35657 # GL/glext.h:421
GL_MAX_VERTEX_UNIFORM_COMPONENTS = 35658 # GL/glext.h:422
GL_MAX_VARYING_FLOATS = 35659 # GL/glext.h:423
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660 # GL/glext.h:424
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661 # GL/glext.h:425
GL_SHADER_TYPE = 35663 # GL/glext.h:426
GL_FLOAT_VEC2 = 35664 # GL/glext.h:427
GL_FLOAT_VEC3 = 35665 # GL/glext.h:428
GL_FLOAT_VEC4 = 35666 # GL/glext.h:429
GL_INT_VEC2 = 35667 # GL/glext.h:430
GL_INT_VEC3 = 35668 # GL/glext.h:431
GL_INT_VEC4 = 35669 # GL/glext.h:432
GL_BOOL = 35670 # GL/glext.h:433
GL_BOOL_VEC2 = 35671 # GL/glext.h:434
GL_BOOL_VEC3 = 35672 # GL/glext.h:435
GL_BOOL_VEC4 = 35673 # GL/glext.h:436
GL_FLOAT_MAT2 = 35674 # GL/glext.h:437
GL_FLOAT_MAT3 = 35675 # GL/glext.h:438
GL_FLOAT_MAT4 = 35676 # GL/glext.h:439
GL_SAMPLER_1D = 35677 # GL/glext.h:440
GL_SAMPLER_2D = 35678 # GL/glext.h:441
GL_SAMPLER_3D = 35679 # GL/glext.h:442
GL_SAMPLER_CUBE = 35680 # GL/glext.h:443
GL_SAMPLER_1D_SHADOW = 35681 # GL/glext.h:444
GL_SAMPLER_2D_SHADOW = 35682 # GL/glext.h:445
GL_DELETE_STATUS = 35712 # GL/glext.h:446
GL_COMPILE_STATUS = 35713 # GL/glext.h:447
GL_LINK_STATUS = 35714 # GL/glext.h:448
GL_VALIDATE_STATUS = 35715 # GL/glext.h:449
GL_INFO_LOG_LENGTH = 35716 # GL/glext.h:450
GL_ATTACHED_SHADERS = 35717 # GL/glext.h:451
GL_ACTIVE_UNIFORMS = 35718 # GL/glext.h:452
GL_ACTIVE_UNIFORM_MAX_LENGTH = 35719 # GL/glext.h:453
GL_SHADER_SOURCE_LENGTH = 35720 # GL/glext.h:454
GL_ACTIVE_ATTRIBUTES = 35721 # GL/glext.h:455
GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 35722 # GL/glext.h:456
GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 35723 # GL/glext.h:457
GL_SHADING_LANGUAGE_VERSION = 35724 # GL/glext.h:458
GL_CURRENT_PROGRAM = 35725 # GL/glext.h:459
GL_POINT_SPRITE_COORD_ORIGIN = 36000 # GL/glext.h:460
GL_LOWER_LEFT = 36001 # GL/glext.h:461
GL_UPPER_LEFT = 36002 # GL/glext.h:462
GL_STENCIL_BACK_REF = 36003 # GL/glext.h:463
GL_STENCIL_BACK_VALUE_MASK = 36004 # GL/glext.h:464
GL_STENCIL_BACK_WRITEMASK = 36005 # GL/glext.h:465
# VERSION_2_0_DEPRECATED (GL/glext.h:468)
GL_VERTEX_PROGRAM_TWO_SIDE = 34371 # GL/glext.h:469
GL_POINT_SPRITE = 34913 # GL/glext.h:470
GL_COORD_REPLACE = 34914 # GL/glext.h:471
GL_MAX_TEXTURE_COORDS = 34929 # GL/glext.h:472
# VERSION_2_1 (GL/glext.h:475)
GL_PIXEL_PACK_BUFFER = 35051 # GL/glext.h:476
GL_PIXEL_UNPACK_BUFFER = 35052 # GL/glext.h:477
GL_PIXEL_PACK_BUFFER_BINDING = 35053 # GL/glext.h:478
GL_PIXEL_UNPACK_BUFFER_BINDING = 35055 # GL/glext.h:479
GL_FLOAT_MAT2x3 = 35685 # GL/glext.h:480
GL_FLOAT_MAT2x4 = 35686 # GL/glext.h:481
GL_FLOAT_MAT3x2 = 35687 # GL/glext.h:482
GL_FLOAT_MAT3x4 = 35688 # GL/glext.h:483
GL_FLOAT_MAT4x2 = 35689 # GL/glext.h:484
GL_FLOAT_MAT4x3 = 35690 # GL/glext.h:485
GL_SRGB = 35904 # GL/glext.h:486
GL_SRGB8 = 35905 # GL/glext.h:487
GL_SRGB_ALPHA = 35906 # GL/glext.h:488
GL_SRGB8_ALPHA8 = 35907 # GL/glext.h:489
GL_COMPRESSED_SRGB = 35912 # GL/glext.h:490
GL_COMPRESSED_SRGB_ALPHA = 35913 # GL/glext.h:491
# VERSION_2_1_DEPRECATED (GL/glext.h:494)
GL_CURRENT_RASTER_SECONDARY_COLOR = 33887 # GL/glext.h:495
GL_SLUMINANCE_ALPHA = 35908 # GL/glext.h:496
GL_SLUMINANCE8_ALPHA8 = 35909 # GL/glext.h:497
GL_SLUMINANCE = 35910 # GL/glext.h:498
GL_SLUMINANCE8 = 35911 # GL/glext.h:499
GL_COMPRESSED_SLUMINANCE = 35914 # GL/glext.h:500
GL_COMPRESSED_SLUMINANCE_ALPHA = 35915 # GL/glext.h:501
# VERSION_3_0 (GL/glext.h:504)
GL_COMPARE_REF_TO_TEXTURE = 34894 # GL/glext.h:505
GL_CLIP_DISTANCE0 = 12288 # GL/glext.h:506
GL_CLIP_DISTANCE1 = 12289 # GL/glext.h:507
GL_CLIP_DISTANCE2 = 12290 # GL/glext.h:508
GL_CLIP_DISTANCE3 = 12291 # GL/glext.h:509
GL_CLIP_DISTANCE4 = 12292 # GL/glext.h:510
GL_CLIP_DISTANCE5 = 12293 # GL/glext.h:511
GL_CLIP_DISTANCE6 = 12294 # GL/glext.h:512
GL_CLIP_DISTANCE7 = 12295 # GL/glext.h:513
GL_MAX_CLIP_DISTANCES = 3378 # GL/glext.h:514
GL_MAJOR_VERSION = 33307 # GL/glext.h:515
GL_MINOR_VERSION = 33308 # GL/glext.h:516
GL_NUM_EXTENSIONS = 33309 # GL/glext.h:517
GL_CONTEXT_FLAGS = 33310 # GL/glext.h:518
GL_COMPRESSED_RED = 33317 # GL/glext.h:519
GL_COMPRESSED_RG = 33318 # GL/glext.h:520
GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 1 # GL/glext.h:521
GL_RGBA32F = 34836 # GL/glext.h:522
GL_RGB32F = 34837 # GL/glext.h:523
GL_RGBA16F = 34842 # GL/glext.h:524
GL_RGB16F = 34843 # GL/glext.h:525
GL_VERTEX_ATTRIB_ARRAY_INTEGER = 35069 # GL/glext.h:526
GL_MAX_ARRAY_TEXTURE_LAYERS = 35071 # GL/glext.h:527
GL_MIN_PROGRAM_TEXEL_OFFSET = 35076 # GL/glext.h:528
GL_MAX_PROGRAM_TEXEL_OFFSET = 35077 # GL/glext.h:529
GL_CLAMP_READ_COLOR = 35100 # GL/glext.h:530
GL_FIXED_ONLY = 35101 # GL/glext.h:531
GL_MAX_VARYING_COMPONENTS = 35659 # GL/glext.h:532
GL_TEXTURE_1D_ARRAY = 35864 # GL/glext.h:533
GL_PROXY_TEXTURE_1D_ARRAY = 35865 # GL/glext.h:534
GL_TEXTURE_2D_ARRAY = 35866 # GL/glext.h:535
GL_PROXY_TEXTURE_2D_ARRAY = 35867 # GL/glext.h:536
GL_TEXTURE_BINDING_1D_ARRAY = 35868 # GL/glext.h:537
GL_TEXTURE_BINDING_2D_ARRAY = 35869 # GL/glext.h:538
GL_R11F_G11F_B10F = 35898 # GL/glext.h:539
GL_UNSIGNED_INT_10F_11F_11F_REV = 35899 # GL/glext.h:540
GL_RGB9_E5 = 35901 # GL/glext.h:541
GL_UNSIGNED_INT_5_9_9_9_REV = 35902 # GL/glext.h:542
GL_TEXTURE_SHARED_SIZE = 35903 # GL/glext.h:543
GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 35958 # GL/glext.h:544
GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 35967 # GL/glext.h:545
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 35968 # GL/glext.h:546
GL_TRANSFORM_FEEDBACK_VARYINGS = 35971 # GL/glext.h:547
GL_TRANSFORM_FEEDBACK_BUFFER_START = 35972 # GL/glext.h:548
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 35973 # GL/glext.h:549
GL_PRIMITIVES_GENERATED = 35975 # GL/glext.h:550
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976 # GL/glext.h:551
GL_RASTERIZER_DISCARD = 35977 # GL/glext.h:552
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 35978 # GL/glext.h:553
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 35979 # GL/glext.h:554
GL_INTERLEAVED_ATTRIBS = 35980 # GL/glext.h:555
GL_SEPARATE_ATTRIBS = 35981 # GL/glext.h:556
GL_TRANSFORM_FEEDBACK_BUFFER = 35982 # GL/glext.h:557
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 35983 # GL/glext.h:558
GL_RGBA32UI = 36208 # GL/glext.h:559
GL_RGB32UI = 36209 # GL/glext.h:560
GL_RGBA16UI = 36214 # GL/glext.h:561
GL_RGB16UI = 36215 # GL/glext.h:562
GL_RGBA8UI = 36220 # GL/glext.h:563
GL_RGB8UI = 36221 # GL/glext.h:564
GL_RGBA32I = 36226 # GL/glext.h:565
GL_RGB32I = 36227 # GL/glext.h:566
GL_RGBA16I = 36232 # GL/glext.h:567
GL_RGB16I = 36233 # GL/glext.h:568
GL_RGBA8I = 36238 # GL/glext.h:569
GL_RGB8I = 36239 # GL/glext.h:570
GL_RED_INTEGER = 36244 # GL/glext.h:571
GL_GREEN_INTEGER = 36245 # GL/glext.h:572
GL_BLUE_INTEGER = 36246 # GL/glext.h:573
GL_RGB_INTEGER = 36248 # GL/glext.h:574
GL_RGBA_INTEGER = 36249 # GL/glext.h:575
GL_BGR_INTEGER = 36250 # GL/glext.h:576
GL_BGRA_INTEGER = 36251 # GL/glext.h:577
GL_SAMPLER_1D_ARRAY = 36288 # GL/glext.h:578
GL_SAMPLER_2D_ARRAY = 36289 # GL/glext.h:579
GL_SAMPLER_1D_ARRAY_SHADOW = 36291 # GL/glext.h:580
GL_SAMPLER_2D_ARRAY_SHADOW = 36292 # GL/glext.h:581
GL_SAMPLER_CUBE_SHADOW = 36293 # GL/glext.h:582
GL_UNSIGNED_INT_VEC2 = 36294 # GL/glext.h:583
GL_UNSIGNED_INT_VEC3 = 36295 # GL/glext.h:584
GL_UNSIGNED_INT_VEC4 = 36296 # GL/glext.h:585
GL_INT_SAMPLER_1D = 36297 # GL/glext.h:586
GL_INT_SAMPLER_2D = 36298 # GL/glext.h:587
GL_INT_SAMPLER_3D = 36299 # GL/glext.h:588
GL_INT_SAMPLER_CUBE = 36300 # GL/glext.h:589
GL_INT_SAMPLER_1D_ARRAY = 36302 # GL/glext.h:590
GL_INT_SAMPLER_2D_ARRAY = 36303 # GL/glext.h:591
GL_UNSIGNED_INT_SAMPLER_1D = 36305 # GL/glext.h:592
GL_UNSIGNED_INT_SAMPLER_2D = 36306 # GL/glext.h:593
GL_UNSIGNED_INT_SAMPLER_3D = 36307 # GL/glext.h:594
GL_UNSIGNED_INT_SAMPLER_CUBE = 36308 # GL/glext.h:595
GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 36310 # GL/glext.h:596
GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 36311 # GL/glext.h:597
GL_QUERY_WAIT = 36371 # GL/glext.h:598
GL_QUERY_NO_WAIT = 36372 # GL/glext.h:599
GL_QUERY_BY_REGION_WAIT = 36373 # GL/glext.h:600
GL_QUERY_BY_REGION_NO_WAIT = 36374 # GL/glext.h:601
GL_BUFFER_ACCESS_FLAGS = 37151 # GL/glext.h:602
GL_BUFFER_MAP_LENGTH = 37152 # GL/glext.h:603
GL_BUFFER_MAP_OFFSET = 37153 # GL/glext.h:604
# VERSION_3_0_DEPRECATED (GL/glext.h:731)
GL_CLAMP_VERTEX_COLOR = 35098 # GL/glext.h:732
GL_CLAMP_FRAGMENT_COLOR = 35099 # GL/glext.h:733
GL_ALPHA_INTEGER = 36247 # GL/glext.h:734
# VERSION_3_1 (GL/glext.h:740)
GL_SAMPLER_2D_RECT = 35683 # GL/glext.h:741
GL_SAMPLER_2D_RECT_SHADOW = 35684 # GL/glext.h:742
GL_SAMPLER_BUFFER = 36290 # GL/glext.h:743
GL_INT_SAMPLER_2D_RECT = 36301 # GL/glext.h:744
GL_INT_SAMPLER_BUFFER = 36304 # GL/glext.h:745
GL_UNSIGNED_INT_SAMPLER_2D_RECT = 36309 # GL/glext.h:746
GL_UNSIGNED_INT_SAMPLER_BUFFER = 36312 # GL/glext.h:747
GL_TEXTURE_BUFFER = 35882 # GL/glext.h:748
GL_MAX_TEXTURE_BUFFER_SIZE = 35883 # GL/glext.h:749
GL_TEXTURE_BINDING_BUFFER = 35884 # GL/glext.h:750
GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 35885 # GL/glext.h:751
GL_TEXTURE_BUFFER_FORMAT = 35886 # GL/glext.h:752
GL_TEXTURE_RECTANGLE = 34037 # GL/glext.h:753
GL_TEXTURE_BINDING_RECTANGLE = 34038 # GL/glext.h:754
GL_PROXY_TEXTURE_RECTANGLE = 34039 # GL/glext.h:755
GL_MAX_RECTANGLE_TEXTURE_SIZE = 34040 # GL/glext.h:756
GL_RED_SNORM = 36752 # GL/glext.h:757
GL_RG_SNORM = 36753 # GL/glext.h:758
GL_RGB_SNORM = 36754 # GL/glext.h:759
GL_RGBA_SNORM = 36755 # GL/glext.h:760
GL_R8_SNORM = 36756 # GL/glext.h:761
GL_RG8_SNORM = 36757 # GL/glext.h:762
GL_RGB8_SNORM = 36758 # GL/glext.h:763
GL_RGBA8_SNORM = 36759 # GL/glext.h:764
GL_R16_SNORM = 36760 # GL/glext.h:765
GL_RG16_SNORM = 36761 # GL/glext.h:766
GL_RGB16_SNORM = 36762 # GL/glext.h:767
GL_RGBA16_SNORM = 36763 # GL/glext.h:768
GL_SIGNED_NORMALIZED = 36764 # GL/glext.h:769
GL_PRIMITIVE_RESTART = 36765 # GL/glext.h:770
GL_PRIMITIVE_RESTART_INDEX = 36766 # GL/glext.h:771
# VERSION_3_2 (GL/glext.h:809)
GL_CONTEXT_CORE_PROFILE_BIT = 1 # GL/glext.h:810
GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 2 # GL/glext.h:811
GL_LINES_ADJACENCY = 10 # GL/glext.h:812
GL_LINE_STRIP_ADJACENCY = 11 # GL/glext.h:813
GL_TRIANGLES_ADJACENCY = 12 # GL/glext.h:814
GL_TRIANGLE_STRIP_ADJACENCY = 13 # GL/glext.h:815
GL_PROGRAM_POINT_SIZE = 34370 # GL/glext.h:816
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 35881 # GL/glext.h:817
GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 36263 # GL/glext.h:818
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 36264 # GL/glext.h:819
GL_GEOMETRY_SHADER = 36313 # GL/glext.h:820
GL_GEOMETRY_VERTICES_OUT = 35094 # GL/glext.h:821
GL_GEOMETRY_INPUT_TYPE = 35095 # GL/glext.h:822
GL_GEOMETRY_OUTPUT_TYPE = 35096 # GL/glext.h:823
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 36319 # GL/glext.h:824
GL_MAX_GEOMETRY_OUTPUT_VERTICES = 36320 # GL/glext.h:825
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 36321 # GL/glext.h:826
GL_MAX_VERTEX_OUTPUT_COMPONENTS = 37154 # GL/glext.h:827
GL_MAX_GEOMETRY_INPUT_COMPONENTS = 37155 # GL/glext.h:828
GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 37156 # GL/glext.h:829
GL_MAX_FRAGMENT_INPUT_COMPONENTS = 37157 # GL/glext.h:830
GL_CONTEXT_PROFILE_MASK = 37158 # GL/glext.h:831
# VERSION_3_3 (GL/glext.h:887)
GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 35070 # GL/glext.h:888
# VERSION_4_0 (GL/glext.h:915)
GL_SAMPLE_SHADING = 35894 # GL/glext.h:916
GL_MIN_SAMPLE_SHADING_VALUE = 35895 # GL/glext.h:917
GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 36446 # GL/glext.h:918
GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 36447 # GL/glext.h:919
GL_TEXTURE_CUBE_MAP_ARRAY = 36873 # GL/glext.h:920
GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = 36874 # GL/glext.h:921
GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = 36875 # GL/glext.h:922
GL_SAMPLER_CUBE_MAP_ARRAY = 36876 # GL/glext.h:923
GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = 36877 # GL/glext.h:924
GL_INT_SAMPLER_CUBE_MAP_ARRAY = 36878 # GL/glext.h:925
GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 36879 # GL/glext.h:926
# VERSION_4_1 (GL/glext.h:1006)
# VERSION_4_2 (GL/glext.h:1049)
# ARB_multitexture (GL/glext.h:1167)
# ARB_transpose_matrix (GL/glext.h:1205)
GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 34019 # GL/glext.h:1206
GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 34020 # GL/glext.h:1207
GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 34021 # GL/glext.h:1208
GL_TRANSPOSE_COLOR_MATRIX_ARB = 34022 # GL/glext.h:1209
# ARB_multisample (GL/glext.h:1212)
GL_MULTISAMPLE_ARB = 32925 # GL/glext.h:1213
GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 32926 # GL/glext.h:1214
GL_SAMPLE_ALPHA_TO_ONE_ARB = 32927 # GL/glext.h:1215
GL_SAMPLE_COVERAGE_ARB = 32928 # GL/glext.h:1216
GL_SAMPLE_BUFFERS_ARB = 32936 # GL/glext.h:1217
GL_SAMPLES_ARB = 32937 # GL/glext.h:1218
GL_SAMPLE_COVERAGE_VALUE_ARB = 32938 # GL/glext.h:1219
GL_SAMPLE_COVERAGE_INVERT_ARB = 32939 # GL/glext.h:1220
GL_MULTISAMPLE_BIT_ARB = 536870912 # GL/glext.h:1221
# ARB_texture_env_add (GL/glext.h:1224)
# ARB_texture_cube_map (GL/glext.h:1227)
GL_NORMAL_MAP_ARB = 34065 # GL/glext.h:1228
GL_REFLECTION_MAP_ARB = 34066 # GL/glext.h:1229
GL_TEXTURE_CUBE_MAP_ARB = 34067 # GL/glext.h:1230
GL_TEXTURE_BINDING_CUBE_MAP_ARB = 34068 # GL/glext.h:1231
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 34069 # GL/glext.h:1232
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 34070 # GL/glext.h:1233
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 34071 # GL/glext.h:1234
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 34072 # GL/glext.h:1235
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 34073 # GL/glext.h:1236
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 34074 # GL/glext.h:1237
GL_PROXY_TEXTURE_CUBE_MAP_ARB = 34075 # GL/glext.h:1238
GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 34076 # GL/glext.h:1239
# ARB_texture_compression (GL/glext.h:1242)
GL_COMPRESSED_ALPHA_ARB = 34025 # GL/glext.h:1243
GL_COMPRESSED_LUMINANCE_ARB = 34026 # GL/glext.h:1244
GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 34027 # GL/glext.h:1245
GL_COMPRESSED_INTENSITY_ARB = 34028 # GL/glext.h:1246
GL_COMPRESSED_RGB_ARB = 34029 # GL/glext.h:1247
GL_COMPRESSED_RGBA_ARB = 34030 # GL/glext.h:1248
GL_TEXTURE_COMPRESSION_HINT_ARB = 34031 # GL/glext.h:1249
GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 34464 # GL/glext.h:1250
GL_TEXTURE_COMPRESSED_ARB = 34465 # GL/glext.h:1251
GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 34466 # GL/glext.h:1252
GL_COMPRESSED_TEXTURE_FORMATS_ARB = 34467 # GL/glext.h:1253
# ARB_texture_border_clamp (GL/glext.h:1256)
GL_CLAMP_TO_BORDER_ARB = 33069 # GL/glext.h:1257
# ARB_point_parameters (GL/glext.h:1260)
GL_POINT_SIZE_MIN_ARB = 33062 # GL/glext.h:1261
GL_POINT_SIZE_MAX_ARB = 33063 # GL/glext.h:1262
GL_POINT_FADE_THRESHOLD_SIZE_ARB = 33064 # GL/glext.h:1263
GL_POINT_DISTANCE_ATTENUATION_ARB = 33065 # GL/glext.h:1264
# ARB_vertex_blend (GL/glext.h:1267)
GL_MAX_VERTEX_UNITS_ARB = 34468 # GL/glext.h:1268
GL_ACTIVE_VERTEX_UNITS_ARB = 34469 # GL/glext.h:1269
GL_WEIGHT_SUM_UNITY_ARB = 34470 # GL/glext.h:1270
GL_VERTEX_BLEND_ARB = 34471 # GL/glext.h:1271
GL_CURRENT_WEIGHT_ARB = 34472 # GL/glext.h:1272
GL_WEIGHT_ARRAY_TYPE_ARB = 34473 # GL/glext.h:1273
GL_WEIGHT_ARRAY_STRIDE_ARB = 34474 # GL/glext.h:1274
GL_WEIGHT_ARRAY_SIZE_ARB = 34475 # GL/glext.h:1275
GL_WEIGHT_ARRAY_POINTER_ARB = 34476 # GL/glext.h:1276
GL_WEIGHT_ARRAY_ARB = 34477 # GL/glext.h:1277
GL_MODELVIEW0_ARB = 5888 # GL/glext.h:1278
GL_MODELVIEW1_ARB = 34058 # GL/glext.h:1279
GL_MODELVIEW2_ARB = 34594 # GL/glext.h:1280
GL_MODELVIEW3_ARB = 34595 # GL/glext.h:1281
GL_MODELVIEW4_ARB = 34596 # GL/glext.h:1282
GL_MODELVIEW5_ARB = 34597 # GL/glext.h:1283
GL_MODELVIEW6_ARB = 34598 # GL/glext.h:1284
GL_MODELVIEW7_ARB = 34599 # GL/glext.h:1285
GL_MODELVIEW8_ARB = 34600 # GL/glext.h:1286
GL_MODELVIEW9_ARB = 34601 # GL/glext.h:1287
GL_MODELVIEW10_ARB = 34602 # GL/glext.h:1288
GL_MODELVIEW11_ARB = 34603 # GL/glext.h:1289
GL_MODELVIEW12_ARB = 34604 # GL/glext.h:1290
GL_MODELVIEW13_ARB = 34605 # GL/glext.h:1291
GL_MODELVIEW14_ARB = 34606 # GL/glext.h:1292
GL_MODELVIEW15_ARB = 34607 # GL/glext.h:1293
GL_MODELVIEW16_ARB = 34608 # GL/glext.h:1294
GL_MODELVIEW17_ARB = 34609 # GL/glext.h:1295
GL_MODELVIEW18_ARB = 34610 # GL/glext.h:1296
GL_MODELVIEW19_ARB = 34611 # GL/glext.h:1297
GL_MODELVIEW20_ARB = 34612 # GL/glext.h:1298
GL_MODELVIEW21_ARB = 34613 # GL/glext.h:1299
GL_MODELVIEW22_ARB = 34614 # GL/glext.h:1300
GL_MODELVIEW23_ARB = 34615 # GL/glext.h:1301
GL_MODELVIEW24_ARB = 34616 # GL/glext.h:1302
GL_MODELVIEW25_ARB = 34617 # GL/glext.h:1303
GL_MODELVIEW26_ARB = 34618 # GL/glext.h:1304
GL_MODELVIEW27_ARB = 34619 # GL/glext.h:1305
GL_MODELVIEW28_ARB = 34620 # GL/glext.h:1306
GL_MODELVIEW29_ARB = 34621 # GL/glext.h:1307
GL_MODELVIEW30_ARB = 34622 # GL/glext.h:1308
GL_MODELVIEW31_ARB = 34623 # GL/glext.h:1309
# ARB_matrix_palette (GL/glext.h:1312)
GL_MATRIX_PALETTE_ARB = 34880 # GL/glext.h:1313
GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 34881 # GL/glext.h:1314
GL_MAX_PALETTE_MATRICES_ARB = 34882 # GL/glext.h:1315
GL_CURRENT_PALETTE_MATRIX_ARB = 34883 # GL/glext.h:1316
GL_MATRIX_INDEX_ARRAY_ARB = 34884 # GL/glext.h:1317
GL_CURRENT_MATRIX_INDEX_ARB = 34885 # GL/glext.h:1318
GL_MATRIX_INDEX_ARRAY_SIZE_ARB = 34886 # GL/glext.h:1319
GL_MATRIX_INDEX_ARRAY_TYPE_ARB = 34887 # GL/glext.h:1320
GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = 34888 # GL/glext.h:1321
GL_MATRIX_INDEX_ARRAY_POINTER_ARB = 34889 # GL/glext.h:1322
# ARB_texture_env_combine (GL/glext.h:1325)
GL_COMBINE_ARB = 34160 # GL/glext.h:1326
GL_COMBINE_RGB_ARB = 34161 # GL/glext.h:1327
GL_COMBINE_ALPHA_ARB = 34162 # GL/glext.h:1328
GL_SOURCE0_RGB_ARB = 34176 # GL/glext.h:1329
GL_SOURCE1_RGB_ARB = 34177 # GL/glext.h:1330
GL_SOURCE2_RGB_ARB = 34178 # GL/glext.h:1331
GL_SOURCE0_ALPHA_ARB = 34184 # GL/glext.h:1332
GL_SOURCE1_ALPHA_ARB = 34185 # GL/glext.h:1333
GL_SOURCE2_ALPHA_ARB = 34186 # GL/glext.h:1334
GL_OPERAND0_RGB_ARB = 34192 # GL/glext.h:1335
GL_OPERAND1_RGB_ARB = 34193 # GL/glext.h:1336
GL_OPERAND2_RGB_ARB = 34194 # GL/glext.h:1337
GL_OPERAND0_ALPHA_ARB = 34200 # GL/glext.h:1338
GL_OPERAND1_ALPHA_ARB = 34201 # GL/glext.h:1339
GL_OPERAND2_ALPHA_ARB = 34202 # GL/glext.h:1340
GL_RGB_SCALE_ARB = 34163 # GL/glext.h:1341
GL_ADD_SIGNED_ARB = 34164 # GL/glext.h:1342
GL_INTERPOLATE_ARB = 34165 # GL/glext.h:1343
GL_SUBTRACT_ARB = 34023 # GL/glext.h:1344
GL_CONSTANT_ARB = 34166 # GL/glext.h:1345
GL_PRIMARY_COLOR_ARB = 34167 # GL/glext.h:1346
GL_PREVIOUS_ARB = 34168 # GL/glext.h:1347
# ARB_texture_env_crossbar (GL/glext.h:1350)
# ARB_texture_env_dot3 (GL/glext.h:1353)
GL_DOT3_RGB_ARB = 34478 # GL/glext.h:1354
GL_DOT3_RGBA_ARB = 34479 # GL/glext.h:1355
# ARB_texture_mirrored_repeat (GL/glext.h:1358)
GL_MIRRORED_REPEAT_ARB = 33648 # GL/glext.h:1359
# ARB_depth_texture (GL/glext.h:1362)
GL_DEPTH_COMPONENT16_ARB = 33189 # GL/glext.h:1363
GL_DEPTH_COMPONENT24_ARB = 33190 # GL/glext.h:1364
GL_DEPTH_COMPONENT32_ARB = 33191 # GL/glext.h:1365
GL_TEXTURE_DEPTH_SIZE_ARB = 34890 # GL/glext.h:1366
GL_DEPTH_TEXTURE_MODE_ARB = 34891 # GL/glext.h:1367
# ARB_shadow (GL/glext.h:1370)
GL_TEXTURE_COMPARE_MODE_ARB = 34892 # GL/glext.h:1371
GL_TEXTURE_COMPARE_FUNC_ARB = 34893 # GL/glext.h:1372
GL_COMPARE_R_TO_TEXTURE_ARB = 34894 # GL/glext.h:1373
# ARB_shadow_ambient (GL/glext.h:1376)
GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 32959 # GL/glext.h:1377
# ARB_window_pos (GL/glext.h:1380)
# ARB_vertex_program (GL/glext.h:1383)
GL_COLOR_SUM_ARB = 33880 # GL/glext.h:1384
GL_VERTEX_PROGRAM_ARB = 34336 # GL/glext.h:1385
GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 34338 # GL/glext.h:1386
GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 34339 # GL/glext.h:1387
GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 34340 # GL/glext.h:1388
GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 34341 # GL/glext.h:1389
GL_CURRENT_VERTEX_ATTRIB_ARB = 34342 # GL/glext.h:1390
GL_PROGRAM_LENGTH_ARB = 34343 # GL/glext.h:1391
GL_PROGRAM_STRING_ARB = 34344 # GL/glext.h:1392
GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 34350 # GL/glext.h:1393
GL_MAX_PROGRAM_MATRICES_ARB = 34351 # GL/glext.h:1394
GL_CURRENT_MATRIX_STACK_DEPTH_ARB = 34368 # GL/glext.h:1395
GL_CURRENT_MATRIX_ARB = 34369 # GL/glext.h:1396
GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 34370 # GL/glext.h:1397
GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 34371 # GL/glext.h:1398
GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 34373 # GL/glext.h:1399
GL_PROGRAM_ERROR_POSITION_ARB = 34379 # GL/glext.h:1400
GL_PROGRAM_BINDING_ARB = 34423 # GL/glext.h:1401
GL_MAX_VERTEX_ATTRIBS_ARB = 34921 # GL/glext.h:1402
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 34922 # GL/glext.h:1403
GL_PROGRAM_ERROR_STRING_ARB = 34932 # GL/glext.h:1404
GL_PROGRAM_FORMAT_ASCII_ARB = 34933 # GL/glext.h:1405
GL_PROGRAM_FORMAT_ARB = 34934 # GL/glext.h:1406
GL_PROGRAM_INSTRUCTIONS_ARB = 34976 # GL/glext.h:1407
GL_MAX_PROGRAM_INSTRUCTIONS_ARB = 34977 # GL/glext.h:1408
GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 34978 # GL/glext.h:1409
GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 34979 # GL/glext.h:1410
GL_PROGRAM_TEMPORARIES_ARB = 34980 # GL/glext.h:1411
GL_MAX_PROGRAM_TEMPORARIES_ARB = 34981 # GL/glext.h:1412
GL_PROGRAM_NATIVE_TEMPORARIES_ARB = 34982 # GL/glext.h:1413
GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 34983 # GL/glext.h:1414
GL_PROGRAM_PARAMETERS_ARB = 34984 # GL/glext.h:1415
GL_MAX_PROGRAM_PARAMETERS_ARB = 34985 # GL/glext.h:1416
GL_PROGRAM_NATIVE_PARAMETERS_ARB = 34986 # GL/glext.h:1417
GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 34987 # GL/glext.h:1418
GL_PROGRAM_ATTRIBS_ARB = 34988 # GL/glext.h:1419
GL_MAX_PROGRAM_ATTRIBS_ARB = 34989 # GL/glext.h:1420
GL_PROGRAM_NATIVE_ATTRIBS_ARB = 34990 # GL/glext.h:1421
GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 34991 # GL/glext.h:1422
GL_PROGRAM_ADDRESS_REGISTERS_ARB = 34992 # GL/glext.h:1423
GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 34993 # GL/glext.h:1424
GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 34994 # GL/glext.h:1425
GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 34995 # GL/glext.h:1426
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 34996 # GL/glext.h:1427
GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = 34997 # GL/glext.h:1428
GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 34998 # GL/glext.h:1429
GL_TRANSPOSE_CURRENT_MATRIX_ARB = 34999 # GL/glext.h:1430
GL_MATRIX0_ARB = 35008 # GL/glext.h:1431
GL_MATRIX1_ARB = 35009 # GL/glext.h:1432
GL_MATRIX2_ARB = 35010 # GL/glext.h:1433
GL_MATRIX3_ARB = 35011 # GL/glext.h:1434
GL_MATRIX4_ARB = 35012 # GL/glext.h:1435
GL_MATRIX5_ARB = 35013 # GL/glext.h:1436
GL_MATRIX6_ARB = 35014 # GL/glext.h:1437
GL_MATRIX7_ARB = 35015 # GL/glext.h:1438
GL_MATRIX8_ARB = 35016 # GL/glext.h:1439
GL_MATRIX9_ARB = 35017 # GL/glext.h:1440
GL_MATRIX10_ARB = 35018 # GL/glext.h:1441
GL_MATRIX11_ARB = 35019 # GL/glext.h:1442
GL_MATRIX12_ARB = 35020 # GL/glext.h:1443
GL_MATRIX13_ARB = 35021 # GL/glext.h:1444
GL_MATRIX14_ARB = 35022 # GL/glext.h:1445
GL_MATRIX15_ARB = 35023 # GL/glext.h:1446
GL_MATRIX16_ARB = 35024 # GL/glext.h:1447
GL_MATRIX17_ARB = 35025 # GL/glext.h:1448
GL_MATRIX18_ARB = 35026 # GL/glext.h:1449
GL_MATRIX19_ARB = 35027 # GL/glext.h:1450
GL_MATRIX20_ARB = 35028 # GL/glext.h:1451
GL_MATRIX21_ARB = 35029 # GL/glext.h:1452
GL_MATRIX22_ARB = 35030 # GL/glext.h:1453
GL_MATRIX23_ARB = 35031 # GL/glext.h:1454
GL_MATRIX24_ARB = 35032 # GL/glext.h:1455
GL_MATRIX25_ARB = 35033 # GL/glext.h:1456
GL_MATRIX26_ARB = 35034 # GL/glext.h:1457
GL_MATRIX27_ARB = 35035 # GL/glext.h:1458
GL_MATRIX28_ARB = 35036 # GL/glext.h:1459
GL_MATRIX29_ARB = 35037 # GL/glext.h:1460
GL_MATRIX30_ARB = 35038 # GL/glext.h:1461
GL_MATRIX31_ARB = 35039 # GL/glext.h:1462
# ARB_fragment_program (GL/glext.h:1465)
GL_FRAGMENT_PROGRAM_ARB = 34820 # GL/glext.h:1466
GL_PROGRAM_ALU_INSTRUCTIONS_ARB = 34821 # GL/glext.h:1467
GL_PROGRAM_TEX_INSTRUCTIONS_ARB = 34822 # GL/glext.h:1468
GL_PROGRAM_TEX_INDIRECTIONS_ARB = 34823 # GL/glext.h:1469
GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34824 # GL/glext.h:1470
GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34825 # GL/glext.h:1471
GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34826 # GL/glext.h:1472
GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 34827 # GL/glext.h:1473
GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 34828 # GL/glext.h:1474
GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 34829 # GL/glext.h:1475
GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34830 # GL/glext.h:1476
GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34831 # GL/glext.h:1477
GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34832 # GL/glext.h:1478
GL_MAX_TEXTURE_COORDS_ARB = 34929 # GL/glext.h:1479
GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 34930 # GL/glext.h:1480
# ARB_vertex_buffer_object (GL/glext.h:1483)
GL_BUFFER_SIZE_ARB = 34660 # GL/glext.h:1484
GL_BUFFER_USAGE_ARB = 34661 # GL/glext.h:1485
GL_ARRAY_BUFFER_ARB = 34962 # GL/glext.h:1486
GL_ELEMENT_ARRAY_BUFFER_ARB = 34963 # GL/glext.h:1487
GL_ARRAY_BUFFER_BINDING_ARB = 34964 # GL/glext.h:1488
GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 34965 # GL/glext.h:1489
GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 34966 # GL/glext.h:1490
GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 34967 # GL/glext.h:1491
GL_COLOR_ARRAY_BUFFER_BINDING_ARB = 34968 # GL/glext.h:1492
GL_INDEX_ARRAY_BUFFER_BINDING_ARB = 34969 # GL/glext.h:1493
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 34970 # GL/glext.h:1494
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 34971 # GL/glext.h:1495
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 34972 # GL/glext.h:1496
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 34973 # GL/glext.h:1497
GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 34974 # GL/glext.h:1498
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 34975 # GL/glext.h:1499
GL_READ_ONLY_ARB = 35000 # GL/glext.h:1500
GL_WRITE_ONLY_ARB = 35001 # GL/glext.h:1501
GL_READ_WRITE_ARB = 35002 # GL/glext.h:1502
GL_BUFFER_ACCESS_ARB = 35003 # GL/glext.h:1503
GL_BUFFER_MAPPED_ARB = 35004 # GL/glext.h:1504
GL_BUFFER_MAP_POINTER_ARB = 35005 # GL/glext.h:1505
GL_STREAM_DRAW_ARB = 35040 # GL/glext.h:1506
GL_STREAM_READ_ARB = 35041 # GL/glext.h:1507
GL_STREAM_COPY_ARB = 35042 # GL/glext.h:1508
GL_STATIC_DRAW_ARB = 35044 # GL/glext.h:1509
GL_STATIC_READ_ARB = 35045 # GL/glext.h:1510
GL_STATIC_COPY_ARB = 35046 # GL/glext.h:1511
GL_DYNAMIC_DRAW_ARB = 35048 # GL/glext.h:1512
GL_DYNAMIC_READ_ARB = 35049 # GL/glext.h:1513
GL_DYNAMIC_COPY_ARB = 35050 # GL/glext.h:1514
# ARB_occlusion_query (GL/glext.h:1517)
GL_QUERY_COUNTER_BITS_ARB = 34916 # GL/glext.h:1518
GL_CURRENT_QUERY_ARB = 34917 # GL/glext.h:1519
GL_QUERY_RESULT_ARB = 34918 # GL/glext.h:1520
GL_QUERY_RESULT_AVAILABLE_ARB = 34919 # GL/glext.h:1521
GL_SAMPLES_PASSED_ARB = 35092 # GL/glext.h:1522
# ARB_shader_objects (GL/glext.h:1525)
GL_PROGRAM_OBJECT_ARB = 35648 # GL/glext.h:1526
GL_SHADER_OBJECT_ARB = 35656 # GL/glext.h:1527
GL_OBJECT_TYPE_ARB = 35662 # GL/glext.h:1528
GL_OBJECT_SUBTYPE_ARB = 35663 # GL/glext.h:1529
GL_FLOAT_VEC2_ARB = 35664 # GL/glext.h:1530
GL_FLOAT_VEC3_ARB = 35665 # GL/glext.h:1531
GL_FLOAT_VEC4_ARB = 35666 # GL/glext.h:1532
GL_INT_VEC2_ARB = 35667 # GL/glext.h:1533
GL_INT_VEC3_ARB = 35668 # GL/glext.h:1534
GL_INT_VEC4_ARB = 35669 # GL/glext.h:1535
GL_BOOL_ARB = 35670 # GL/glext.h:1536
GL_BOOL_VEC2_ARB = 35671 # GL/glext.h:1537
GL_BOOL_VEC3_ARB = 35672 # GL/glext.h:1538
GL_BOOL_VEC4_ARB = 35673 # GL/glext.h:1539
GL_FLOAT_MAT2_ARB = 35674 # GL/glext.h:1540
GL_FLOAT_MAT3_ARB = 35675 # GL/glext.h:1541
GL_FLOAT_MAT4_ARB = 35676 # GL/glext.h:1542
GL_SAMPLER_1D_ARB = 35677 # GL/glext.h:1543
GL_SAMPLER_2D_ARB = 35678 # GL/glext.h:1544
GL_SAMPLER_3D_ARB = 35679 # GL/glext.h:1545
GL_SAMPLER_CUBE_ARB = 35680 # GL/glext.h:1546
GL_SAMPLER_1D_SHADOW_ARB = 35681 # GL/glext.h:1547
GL_SAMPLER_2D_SHADOW_ARB = 35682 # GL/glext.h:1548
GL_SAMPLER_2D_RECT_ARB = 35683 # GL/glext.h:1549
GL_SAMPLER_2D_RECT_SHADOW_ARB = 35684 # GL/glext.h:1550
GL_OBJECT_DELETE_STATUS_ARB = 35712 # GL/glext.h:1551
GL_OBJECT_COMPILE_STATUS_ARB = 35713 # GL/glext.h:1552
GL_OBJECT_LINK_STATUS_ARB = 35714 # GL/glext.h:1553
GL_OBJECT_VALIDATE_STATUS_ARB = 35715 # GL/glext.h:1554
GL_OBJECT_INFO_LOG_LENGTH_ARB = 35716 # GL/glext.h:1555
GL_OBJECT_ATTACHED_OBJECTS_ARB = 35717 # GL/glext.h:1556
GL_OBJECT_ACTIVE_UNIFORMS_ARB = 35718 # GL/glext.h:1557
GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 35719 # GL/glext.h:1558
GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 35720 # GL/glext.h:1559
# ARB_vertex_shader (GL/glext.h:1562)
GL_VERTEX_SHADER_ARB = 35633 # GL/glext.h:1563
GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 35658 # GL/glext.h:1564
GL_MAX_VARYING_FLOATS_ARB = 35659 # GL/glext.h:1565
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 35660 # GL/glext.h:1566
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 35661 # GL/glext.h:1567
GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 35721 # GL/glext.h:1568
GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 35722 # GL/glext.h:1569
# ARB_fragment_shader (GL/glext.h:1572)
GL_FRAGMENT_SHADER_ARB = 35632 # GL/glext.h:1573
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 35657 # GL/glext.h:1574
GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 35723 # GL/glext.h:1575
# ARB_shading_language_100 (GL/glext.h:1578)
GL_SHADING_LANGUAGE_VERSION_ARB = 35724 # GL/glext.h:1579
# ARB_texture_non_power_of_two (GL/glext.h:1582)
# ARB_point_sprite (GL/glext.h:1585)
GL_POINT_SPRITE_ARB = 34913 # GL/glext.h:1586
GL_COORD_REPLACE_ARB = 34914 # GL/glext.h:1587
# ARB_fragment_program_shadow (GL/glext.h:1590)
# ARB_draw_buffers (GL/glext.h:1593)
GL_MAX_DRAW_BUFFERS_ARB = 34852 # GL/glext.h:1594
GL_DRAW_BUFFER0_ARB = 34853 # GL/glext.h:1595
GL_DRAW_BUFFER1_ARB = 34854 # GL/glext.h:1596
GL_DRAW_BUFFER2_ARB = 34855 # GL/glext.h:1597
GL_DRAW_BUFFER3_ARB = 34856 # GL/glext.h:1598
GL_DRAW_BUFFER4_ARB = 34857 # GL/glext.h:1599
GL_DRAW_BUFFER5_ARB = 34858 # GL/glext.h:1600
GL_DRAW_BUFFER6_ARB = 34859 # GL/glext.h:1601
GL_DRAW_BUFFER7_ARB = 34860 # GL/glext.h:1602
GL_DRAW_BUFFER8_ARB = 34861 # GL/glext.h:1603
GL_DRAW_BUFFER9_ARB = 34862 # GL/glext.h:1604
GL_DRAW_BUFFER10_ARB = 34863 # GL/glext.h:1605
GL_DRAW_BUFFER11_ARB = 34864 # GL/glext.h:1606
GL_DRAW_BUFFER12_ARB = 34865 # GL/glext.h:1607
GL_DRAW_BUFFER13_ARB = 34866 # GL/glext.h:1608
GL_DRAW_BUFFER14_ARB = 34867 # GL/glext.h:1609
GL_DRAW_BUFFER15_ARB = 34868 # GL/glext.h:1610
# ARB_texture_rectangle (GL/glext.h:1613)
GL_TEXTURE_RECTANGLE_ARB = 34037 # GL/glext.h:1614
GL_TEXTURE_BINDING_RECTANGLE_ARB = 34038 # GL/glext.h:1615
GL_PROXY_TEXTURE_RECTANGLE_ARB = 34039 # GL/glext.h:1616
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 34040 # GL/glext.h:1617
# ARB_color_buffer_float (GL/glext.h:1620)
GL_RGBA_FLOAT_MODE_ARB = 34848 # GL/glext.h:1621
GL_CLAMP_VERTEX_COLOR_ARB = 35098 # GL/glext.h:1622
GL_CLAMP_FRAGMENT_COLOR_ARB = 35099 # GL/glext.h:1623
GL_CLAMP_READ_COLOR_ARB = 35100 # GL/glext.h:1624
GL_FIXED_ONLY_ARB = 35101 # GL/glext.h:1625
# ARB_half_float_pixel (GL/glext.h:1628)
GL_HALF_FLOAT_ARB = 5131 # GL/glext.h:1629
# ARB_texture_float (GL/glext.h:1632)
GL_TEXTURE_RED_TYPE_ARB = 35856 # GL/glext.h:1633
GL_TEXTURE_GREEN_TYPE_ARB = 35857 # GL/glext.h:1634
GL_TEXTURE_BLUE_TYPE_ARB = 35858 # GL/glext.h:1635
GL_TEXTURE_ALPHA_TYPE_ARB = 35859 # GL/glext.h:1636
GL_TEXTURE_LUMINANCE_TYPE_ARB = 35860 # GL/glext.h:1637
GL_TEXTURE_INTENSITY_TYPE_ARB = 35861 # GL/glext.h:1638
GL_TEXTURE_DEPTH_TYPE_ARB = 35862 # GL/glext.h:1639
GL_UNSIGNED_NORMALIZED_ARB = 35863 # GL/glext.h:1640
GL_RGBA32F_ARB = 34836 # GL/glext.h:1641
GL_RGB32F_ARB = 34837 # GL/glext.h:1642
GL_ALPHA32F_ARB = 34838 # GL/glext.h:1643
GL_INTENSITY32F_ARB = 34839 # GL/glext.h:1644
GL_LUMINANCE32F_ARB = 34840 # GL/glext.h:1645
GL_LUMINANCE_ALPHA32F_ARB = 34841 # GL/glext.h:1646
GL_RGBA16F_ARB = 34842 # GL/glext.h:1647
GL_RGB16F_ARB = 34843 # GL/glext.h:1648
GL_ALPHA16F_ARB = 34844 # GL/glext.h:1649
GL_INTENSITY16F_ARB = 34845 # GL/glext.h:1650
GL_LUMINANCE16F_ARB = 34846 # GL/glext.h:1651
GL_LUMINANCE_ALPHA16F_ARB = 34847 # GL/glext.h:1652
# ARB_pixel_buffer_object (GL/glext.h:1655)
GL_PIXEL_PACK_BUFFER_ARB = 35051 # GL/glext.h:1656
GL_PIXEL_UNPACK_BUFFER_ARB = 35052 # GL/glext.h:1657
GL_PIXEL_PACK_BUFFER_BINDING_ARB = 35053 # GL/glext.h:1658
GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 35055 # GL/glext.h:1659
# ARB_depth_buffer_float (GL/glext.h:1662)
GL_DEPTH_COMPONENT32F = 36012 # GL/glext.h:1663
GL_DEPTH32F_STENCIL8 = 36013 # GL/glext.h:1664
GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 36269 # GL/glext.h:1665
# ARB_draw_instanced (GL/glext.h:1668)
# ARB_framebuffer_object (GL/glext.h:1671)
GL_INVALID_FRAMEBUFFER_OPERATION = 1286 # GL/glext.h:1672
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 33296 # GL/glext.h:1673
GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 33297 # GL/glext.h:1674
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 33298 # GL/glext.h:1675
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 33299 # GL/glext.h:1676
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 33300 # GL/glext.h:1677
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 33301 # GL/glext.h:1678
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 33302 # GL/glext.h:1679
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 33303 # GL/glext.h:1680
GL_FRAMEBUFFER_DEFAULT = 33304 # GL/glext.h:1681
GL_FRAMEBUFFER_UNDEFINED = 33305 # GL/glext.h:1682
GL_DEPTH_STENCIL_ATTACHMENT = 33306 # GL/glext.h:1683
GL_MAX_RENDERBUFFER_SIZE = 34024 # GL/glext.h:1684
GL_DEPTH_STENCIL = 34041 # GL/glext.h:1685
GL_UNSIGNED_INT_24_8 = 34042 # GL/glext.h:1686
GL_DEPTH24_STENCIL8 = 35056 # GL/glext.h:1687
GL_TEXTURE_STENCIL_SIZE = 35057 # GL/glext.h:1688
GL_TEXTURE_RED_TYPE = 35856 # GL/glext.h:1689
GL_TEXTURE_GREEN_TYPE = 35857 # GL/glext.h:1690
GL_TEXTURE_BLUE_TYPE = 35858 # GL/glext.h:1691
GL_TEXTURE_ALPHA_TYPE = 35859 # GL/glext.h:1692
GL_TEXTURE_DEPTH_TYPE = 35862 # GL/glext.h:1693
GL_UNSIGNED_NORMALIZED = 35863 # GL/glext.h:1694
GL_FRAMEBUFFER_BINDING = 36006 # GL/glext.h:1695
GL_DRAW_FRAMEBUFFER_BINDING = 36006 # GL/glext.h:1696
GL_RENDERBUFFER_BINDING = 36007 # GL/glext.h:1697
GL_READ_FRAMEBUFFER = 36008 # GL/glext.h:1698
GL_DRAW_FRAMEBUFFER = 36009 # GL/glext.h:1699
GL_READ_FRAMEBUFFER_BINDING = 36010 # GL/glext.h:1700
GL_RENDERBUFFER_SAMPLES = 36011 # GL/glext.h:1701
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048 # GL/glext.h:1702
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049 # GL/glext.h:1703
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050 # GL/glext.h:1704
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051 # GL/glext.h:1705
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 36052 # GL/glext.h:1706
GL_FRAMEBUFFER_COMPLETE = 36053 # GL/glext.h:1707
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054 # GL/glext.h:1708
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055 # GL/glext.h:1709
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059 # GL/glext.h:1710
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060 # GL/glext.h:1711
GL_FRAMEBUFFER_UNSUPPORTED = 36061 # GL/glext.h:1712
GL_MAX_COLOR_ATTACHMENTS = 36063 # GL/glext.h:1713
GL_COLOR_ATTACHMENT0 = 36064 # GL/glext.h:1714
GL_COLOR_ATTACHMENT1 = 36065 # GL/glext.h:1715
GL_COLOR_ATTACHMENT2 = 36066 # GL/glext.h:1716
GL_COLOR_ATTACHMENT3 = 36067 # GL/glext.h:1717
GL_COLOR_ATTACHMENT4 = 36068 # GL/glext.h:1718
GL_COLOR_ATTACHMENT5 = 36069 # GL/glext.h:1719
GL_COLOR_ATTACHMENT6 = 36070 # GL/glext.h:1720
GL_COLOR_ATTACHMENT7 = 36071 # GL/glext.h:1721
GL_COLOR_ATTACHMENT8 = 36072 # GL/glext.h:1722
GL_COLOR_ATTACHMENT9 = 36073 # GL/glext.h:1723
GL_COLOR_ATTACHMENT10 = 36074 # GL/glext.h:1724
GL_COLOR_ATTACHMENT11 = 36075 # GL/glext.h:1725
GL_COLOR_ATTACHMENT12 = 36076 # GL/glext.h:1726
GL_COLOR_ATTACHMENT13 = 36077 # GL/glext.h:1727
GL_COLOR_ATTACHMENT14 = 36078 # GL/glext.h:1728
GL_COLOR_ATTACHMENT15 = 36079 # GL/glext.h:1729
GL_DEPTH_ATTACHMENT = 36096 # GL/glext.h:1730
GL_STENCIL_ATTACHMENT = 36128 # GL/glext.h:1731
GL_FRAMEBUFFER = 36160 # GL/glext.h:1732
GL_RENDERBUFFER = 36161 # GL/glext.h:1733
GL_RENDERBUFFER_WIDTH = 36162 # GL/glext.h:1734
GL_RENDERBUFFER_HEIGHT = 36163 # GL/glext.h:1735
GL_RENDERBUFFER_INTERNAL_FORMAT = 36164 # GL/glext.h:1736
GL_STENCIL_INDEX1 = 36166 # GL/glext.h:1737
GL_STENCIL_INDEX4 = 36167 # GL/glext.h:1738
GL_STENCIL_INDEX8 = 36168 # GL/glext.h:1739
GL_STENCIL_INDEX16 = 36169 # GL/glext.h:1740
GL_RENDERBUFFER_RED_SIZE = 36176 # GL/glext.h:1741
GL_RENDERBUFFER_GREEN_SIZE = 36177 # GL/glext.h:1742
GL_RENDERBUFFER_BLUE_SIZE = 36178 # GL/glext.h:1743
GL_RENDERBUFFER_ALPHA_SIZE = 36179 # GL/glext.h:1744
GL_RENDERBUFFER_DEPTH_SIZE = 36180 # GL/glext.h:1745
GL_RENDERBUFFER_STENCIL_SIZE = 36181 # GL/glext.h:1746
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 36182 # GL/glext.h:1747
GL_MAX_SAMPLES = 36183 # GL/glext.h:1748
# ARB_framebuffer_object_DEPRECATED (GL/glext.h:1751)
GL_INDEX = 33314 # GL/glext.h:1752
GL_TEXTURE_LUMINANCE_TYPE = 35860 # GL/glext.h:1753
GL_TEXTURE_INTENSITY_TYPE = 35861 # GL/glext.h:1754
# ARB_framebuffer_sRGB (GL/glext.h:1757)
GL_FRAMEBUFFER_SRGB = 36281 # GL/glext.h:1758
# ARB_geometry_shader4 (GL/glext.h:1761)
GL_LINES_ADJACENCY_ARB = 10 # GL/glext.h:1762
GL_LINE_STRIP_ADJACENCY_ARB = 11 # GL/glext.h:1763
GL_TRIANGLES_ADJACENCY_ARB = 12 # GL/glext.h:1764
GL_TRIANGLE_STRIP_ADJACENCY_ARB = 13 # GL/glext.h:1765
GL_PROGRAM_POINT_SIZE_ARB = 34370 # GL/glext.h:1766
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 35881 # GL/glext.h:1767
GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 36263 # GL/glext.h:1768
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 36264 # GL/glext.h:1769
GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 36265 # GL/glext.h:1770
GL_GEOMETRY_SHADER_ARB = 36313 # GL/glext.h:1771
GL_GEOMETRY_VERTICES_OUT_ARB = 36314 # GL/glext.h:1772
GL_GEOMETRY_INPUT_TYPE_ARB = 36315 # GL/glext.h:1773
GL_GEOMETRY_OUTPUT_TYPE_ARB = 36316 # GL/glext.h:1774
GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 36317 # GL/glext.h:1775
GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 36318 # GL/glext.h:1776
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 36319 # GL/glext.h:1777
GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 36320 # GL/glext.h:1778
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 36321 # GL/glext.h:1779
# ARB_half_float_vertex (GL/glext.h:1784)
GL_HALF_FLOAT = 5131 # GL/glext.h:1785
# ARB_instanced_arrays (GL/glext.h:1788)
GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 35070 # GL/glext.h:1789
# ARB_map_buffer_range (GL/glext.h:1792)
GL_MAP_READ_BIT = 1 # GL/glext.h:1793
GL_MAP_WRITE_BIT = 2 # GL/glext.h:1794
GL_MAP_INVALIDATE_RANGE_BIT = 4 # GL/glext.h:1795
GL_MAP_INVALIDATE_BUFFER_BIT = 8 # GL/glext.h:1796
GL_MAP_FLUSH_EXPLICIT_BIT = 16 # GL/glext.h:1797
GL_MAP_UNSYNCHRONIZED_BIT = 32 # GL/glext.h:1798
# ARB_texture_buffer_object (GL/glext.h:1801)
GL_TEXTURE_BUFFER_ARB = 35882 # GL/glext.h:1802
GL_MAX_TEXTURE_BUFFER_SIZE_ARB = 35883 # GL/glext.h:1803
GL_TEXTURE_BINDING_BUFFER_ARB = 35884 # GL/glext.h:1804
GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 35885 # GL/glext.h:1805
GL_TEXTURE_BUFFER_FORMAT_ARB = 35886 # GL/glext.h:1806
# ARB_texture_compression_rgtc (GL/glext.h:1809)
GL_COMPRESSED_RED_RGTC1 = 36283 # GL/glext.h:1810
GL_COMPRESSED_SIGNED_RED_RGTC1 = 36284 # GL/glext.h:1811
GL_COMPRESSED_RG_RGTC2 = 36285 # GL/glext.h:1812
GL_COMPRESSED_SIGNED_RG_RGTC2 = 36286 # GL/glext.h:1813
# ARB_texture_rg (GL/glext.h:1816)
GL_RG = 33319 # GL/glext.h:1817
GL_RG_INTEGER = 33320 # GL/glext.h:1818
GL_R8 = 33321 # GL/glext.h:1819
GL_R16 = 33322 # GL/glext.h:1820
GL_RG8 = 33323 # GL/glext.h:1821
GL_RG16 = 33324 # GL/glext.h:1822
GL_R16F = 33325 # GL/glext.h:1823
GL_R32F = 33326 # GL/glext.h:1824
GL_RG16F = 33327 # GL/glext.h:1825
GL_RG32F = 33328 # GL/glext.h:1826
GL_R8I = 33329 # GL/glext.h:1827
GL_R8UI = 33330 # GL/glext.h:1828
GL_R16I = 33331 # GL/glext.h:1829
GL_R16UI = 33332 # GL/glext.h:1830
GL_R32I = 33333 # GL/glext.h:1831
GL_R32UI = 33334 # GL/glext.h:1832
GL_RG8I = 33335 # GL/glext.h:1833
GL_RG8UI = 33336 # GL/glext.h:1834
GL_RG16I = 33337 # GL/glext.h:1835
GL_RG16UI = 33338 # GL/glext.h:1836
GL_RG32I = 33339 # GL/glext.h:1837
GL_RG32UI = 33340 # GL/glext.h:1838
# ARB_vertex_array_object (GL/glext.h:1841)
GL_VERTEX_ARRAY_BINDING = 34229 # GL/glext.h:1842
# ARB_uniform_buffer_object (GL/glext.h:1845)
GL_UNIFORM_BUFFER = 35345 # GL/glext.h:1846
GL_UNIFORM_BUFFER_BINDING = 35368 # GL/glext.h:1847
GL_UNIFORM_BUFFER_START = 35369 # GL/glext.h:1848
GL_UNIFORM_BUFFER_SIZE = 35370 # GL/glext.h:1849
GL_MAX_VERTEX_UNIFORM_BLOCKS = 35371 # GL/glext.h:1850
GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 35372 # GL/glext.h:1851
GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 35373 # GL/glext.h:1852
GL_MAX_COMBINED_UNIFORM_BLOCKS = 35374 # GL/glext.h:1853
GL_MAX_UNIFORM_BUFFER_BINDINGS = 35375 # GL/glext.h:1854
GL_MAX_UNIFORM_BLOCK_SIZE = 35376 # GL/glext.h:1855
GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 35377 # GL/glext.h:1856
GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 35378 # GL/glext.h:1857
GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 35379 # GL/glext.h:1858
GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 35380 # GL/glext.h:1859
GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 35381 # GL/glext.h:1860
GL_ACTIVE_UNIFORM_BLOCKS = 35382 # GL/glext.h:1861
GL_UNIFORM_TYPE = 35383 # GL/glext.h:1862
GL_UNIFORM_SIZE = 35384 # GL/glext.h:1863
GL_UNIFORM_NAME_LENGTH = 35385 # GL/glext.h:1864
GL_UNIFORM_BLOCK_INDEX = 35386 # GL/glext.h:1865
GL_UNIFORM_OFFSET = 35387 # GL/glext.h:1866
GL_UNIFORM_ARRAY_STRIDE = 35388 # GL/glext.h:1867
GL_UNIFORM_MATRIX_STRIDE = 35389 # GL/glext.h:1868
GL_UNIFORM_IS_ROW_MAJOR = 35390 # GL/glext.h:1869
GL_UNIFORM_BLOCK_BINDING = 35391 # GL/glext.h:1870
GL_UNIFORM_BLOCK_DATA_SIZE = 35392 # GL/glext.h:1871
GL_UNIFORM_BLOCK_NAME_LENGTH = 35393 # GL/glext.h:1872
GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 35394 # GL/glext.h:1873
GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 35395 # GL/glext.h:1874
GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 35396 # GL/glext.h:1875
GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 35397 # GL/glext.h:1876
GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 35398 # GL/glext.h:1877
GL_INVALID_INDEX = 4294967295 # GL/glext.h:1878
# ARB_compatibility (GL/glext.h:1881)
# ARB_copy_buffer (GL/glext.h:1885)
GL_COPY_READ_BUFFER_BINDING = 36662 # GL/glext.h:1886
GL_COPY_READ_BUFFER = 36662 # GL/glext.h:1887
GL_COPY_WRITE_BUFFER_BINDING = 36663 # GL/glext.h:1888
GL_COPY_WRITE_BUFFER = 36663 # GL/glext.h:1889
# ARB_shader_texture_lod (GL/glext.h:1892)
# ARB_depth_clamp (GL/glext.h:1895)
GL_DEPTH_CLAMP = 34383 # GL/glext.h:1896
# ARB_draw_elements_base_vertex (GL/glext.h:1899)
# ARB_fragment_coord_conventions (GL/glext.h:1902)
# ARB_provoking_vertex (GL/glext.h:1905)
GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 36428 # GL/glext.h:1906
GL_FIRST_VERTEX_CONVENTION = 36429 # GL/glext.h:1907
GL_LAST_VERTEX_CONVENTION = 36430 # GL/glext.h:1908
GL_PROVOKING_VERTEX = 36431 # GL/glext.h:1909
# ARB_seamless_cube_map (GL/glext.h:1912)
GL_TEXTURE_CUBE_MAP_SEAMLESS = 34895 # GL/glext.h:1913
# ARB_sync (GL/glext.h:1916)
GL_MAX_SERVER_WAIT_TIMEOUT = 37137 # GL/glext.h:1917
GL_OBJECT_TYPE = 37138 # GL/glext.h:1918
GL_SYNC_CONDITION = 37139 # GL/glext.h:1919
GL_SYNC_STATUS = 37140 # GL/glext.h:1920
GL_SYNC_FLAGS = 37141 # GL/glext.h:1921
GL_SYNC_FENCE = 37142 # GL/glext.h:1922
GL_SYNC_GPU_COMMANDS_COMPLETE = 37143 # GL/glext.h:1923
GL_UNSIGNALED = 37144 # GL/glext.h:1924
GL_SIGNALED = 37145 # GL/glext.h:1925
GL_ALREADY_SIGNALED = 37146 # GL/glext.h:1926
GL_TIMEOUT_EXPIRED = 37147 # GL/glext.h:1927
GL_CONDITION_SATISFIED = 37148 # GL/glext.h:1928
GL_WAIT_FAILED = 37149 # GL/glext.h:1929
GL_SYNC_FLUSH_COMMANDS_BIT = 1 # GL/glext.h:1930
GL_TIMEOUT_IGNORED = 18446744073709551615L # GL/glext.h:1931
# ARB_texture_multisample (GL/glext.h:1934)
GL_SAMPLE_POSITION = 36432 # GL/glext.h:1935
GL_SAMPLE_MASK = 36433 # GL/glext.h:1936
GL_SAMPLE_MASK_VALUE = 36434 # GL/glext.h:1937
GL_MAX_SAMPLE_MASK_WORDS = 36441 # GL/glext.h:1938
GL_TEXTURE_2D_MULTISAMPLE = 37120 # GL/glext.h:1939
GL_PROXY_TEXTURE_2D_MULTISAMPLE = 37121 # GL/glext.h:1940
GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 37122 # GL/glext.h:1941
GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 37123 # GL/glext.h:1942
GL_TEXTURE_BINDING_2D_MULTISAMPLE = 37124 # GL/glext.h:1943
GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 37125 # GL/glext.h:1944
GL_TEXTURE_SAMPLES = 37126 # GL/glext.h:1945
GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 37127 # GL/glext.h:1946
GL_SAMPLER_2D_MULTISAMPLE = 37128 # GL/glext.h:1947
GL_INT_SAMPLER_2D_MULTISAMPLE = 37129 # GL/glext.h:1948
GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 37130 # GL/glext.h:1949
GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 37131 # GL/glext.h:1950
GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 37132 # GL/glext.h:1951
GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 37133 # GL/glext.h:1952
GL_MAX_COLOR_TEXTURE_SAMPLES = 37134 # GL/glext.h:1953
GL_MAX_DEPTH_TEXTURE_SAMPLES = 37135 # GL/glext.h:1954
GL_MAX_INTEGER_SAMPLES = 37136 # GL/glext.h:1955
# ARB_vertex_array_bgra (GL/glext.h:1958)
# ARB_draw_buffers_blend (GL/glext.h:1962)
# ARB_sample_shading (GL/glext.h:1965)
GL_SAMPLE_SHADING_ARB = 35894 # GL/glext.h:1966
GL_MIN_SAMPLE_SHADING_VALUE_ARB = 35895 # GL/glext.h:1967
# ARB_texture_cube_map_array (GL/glext.h:1970)
GL_TEXTURE_CUBE_MAP_ARRAY_ARB = 36873 # GL/glext.h:1971
GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 36874 # GL/glext.h:1972
GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 36875 # GL/glext.h:1973
GL_SAMPLER_CUBE_MAP_ARRAY_ARB = 36876 # GL/glext.h:1974
GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 36877 # GL/glext.h:1975
GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 36878 # GL/glext.h:1976
GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 36879 # GL/glext.h:1977
# ARB_texture_gather (GL/glext.h:1980)
GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 36446 # GL/glext.h:1981
GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 36447 # GL/glext.h:1982
# ARB_texture_query_lod (GL/glext.h:1985)
# ARB_shading_language_include (GL/glext.h:1988)
GL_SHADER_INCLUDE_ARB = 36270 # GL/glext.h:1989
GL_NAMED_STRING_LENGTH_ARB = 36329 # GL/glext.h:1990
GL_NAMED_STRING_TYPE_ARB = 36330 # GL/glext.h:1991
# ARB_texture_compression_bptc (GL/glext.h:1994)
GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = 36492 # GL/glext.h:1995
GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 36493 # GL/glext.h:1996
GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 36494 # GL/glext.h:1997
GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 36495 # GL/glext.h:1998
# ARB_blend_func_extended (GL/glext.h:2001)
GL_SRC1_COLOR = 35065 # GL/glext.h:2002
GL_ONE_MINUS_SRC1_COLOR = 35066 # GL/glext.h:2004
GL_ONE_MINUS_SRC1_ALPHA = 35067 # GL/glext.h:2005
GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 35068 # GL/glext.h:2006
# ARB_explicit_attrib_location (GL/glext.h:2009)
# ARB_occlusion_query2 (GL/glext.h:2012)
GL_ANY_SAMPLES_PASSED = 35887 # GL/glext.h:2013
# ARB_sampler_objects (GL/glext.h:2016)
GL_SAMPLER_BINDING = 35097 # GL/glext.h:2017
# ARB_shader_bit_encoding (GL/glext.h:2020)
# ARB_texture_rgb10_a2ui (GL/glext.h:2023)
GL_RGB10_A2UI = 36975 # GL/glext.h:2024
# ARB_texture_swizzle (GL/glext.h:2027)
GL_TEXTURE_SWIZZLE_R = 36418 # GL/glext.h:2028
GL_TEXTURE_SWIZZLE_G = 36419 # GL/glext.h:2029
GL_TEXTURE_SWIZZLE_B = 36420 # GL/glext.h:2030
GL_TEXTURE_SWIZZLE_A = 36421 # GL/glext.h:2031
GL_TEXTURE_SWIZZLE_RGBA = 36422 # GL/glext.h:2032
# ARB_timer_query (GL/glext.h:2035)
GL_TIME_ELAPSED = 35007 # GL/glext.h:2036
GL_TIMESTAMP = 36392 # GL/glext.h:2037
# ARB_vertex_type_2_10_10_10_rev (GL/glext.h:2040)
GL_INT_2_10_10_10_REV = 36255 # GL/glext.h:2042
# ARB_draw_indirect (GL/glext.h:2045)
GL_DRAW_INDIRECT_BUFFER = 36671 # GL/glext.h:2046
GL_DRAW_INDIRECT_BUFFER_BINDING = 36675 # GL/glext.h:2047
# ARB_gpu_shader5 (GL/glext.h:2050)
GL_GEOMETRY_SHADER_INVOCATIONS = 34943 # GL/glext.h:2051
GL_MAX_GEOMETRY_SHADER_INVOCATIONS = 36442 # GL/glext.h:2052
GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = 36443 # GL/glext.h:2053
GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = 36444 # GL/glext.h:2054
GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = 36445 # GL/glext.h:2055
# ARB_gpu_shader_fp64 (GL/glext.h:2059)
GL_DOUBLE_VEC2 = 36860 # GL/glext.h:2061
GL_DOUBLE_VEC3 = 36861 # GL/glext.h:2062
GL_DOUBLE_VEC4 = 36862 # GL/glext.h:2063
GL_DOUBLE_MAT2 = 36678 # GL/glext.h:2064
GL_DOUBLE_MAT3 = 36679 # GL/glext.h:2065
GL_DOUBLE_MAT4 = 36680 # GL/glext.h:2066
GL_DOUBLE_MAT2x3 = 36681 # GL/glext.h:2067
GL_DOUBLE_MAT2x4 = 36682 # GL/glext.h:2068
GL_DOUBLE_MAT3x2 = 36683 # GL/glext.h:2069
GL_DOUBLE_MAT3x4 = 36684 # GL/glext.h:2070
GL_DOUBLE_MAT4x2 = 36685 # GL/glext.h:2071
GL_DOUBLE_MAT4x3 = 36686 # GL/glext.h:2072
# ARB_shader_subroutine (GL/glext.h:2075)
GL_ACTIVE_SUBROUTINES = 36325 # GL/glext.h:2076
GL_ACTIVE_SUBROUTINE_UNIFORMS = 36326 # GL/glext.h:2077
GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 36423 # GL/glext.h:2078
GL_ACTIVE_SUBROUTINE_MAX_LENGTH = 36424 # GL/glext.h:2079
GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 36425 # GL/glext.h:2080
GL_MAX_SUBROUTINES = 36327 # GL/glext.h:2081
GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 36328 # GL/glext.h:2082
GL_NUM_COMPATIBLE_SUBROUTINES = 36426 # GL/glext.h:2083
GL_COMPATIBLE_SUBROUTINES = 36427 # GL/glext.h:2084
# ARB_tessellation_shader (GL/glext.h:2089)
GL_PATCHES = 14 # GL/glext.h:2090
GL_PATCH_VERTICES = 36466 # GL/glext.h:2091
GL_PATCH_DEFAULT_INNER_LEVEL = 36467 # GL/glext.h:2092
GL_PATCH_DEFAULT_OUTER_LEVEL = 36468 # GL/glext.h:2093
GL_TESS_CONTROL_OUTPUT_VERTICES = 36469 # GL/glext.h:2094
GL_TESS_GEN_MODE = 36470 # GL/glext.h:2095
GL_TESS_GEN_SPACING = 36471 # GL/glext.h:2096
GL_TESS_GEN_VERTEX_ORDER = 36472 # GL/glext.h:2097
GL_TESS_GEN_POINT_MODE = 36473 # GL/glext.h:2098
GL_ISOLINES = 36474 # GL/glext.h:2101
GL_FRACTIONAL_ODD = 36475 # GL/glext.h:2103
GL_FRACTIONAL_EVEN = 36476 # GL/glext.h:2104
GL_MAX_PATCH_VERTICES = 36477 # GL/glext.h:2107
GL_MAX_TESS_GEN_LEVEL = 36478 # GL/glext.h:2108
GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 36479 # GL/glext.h:2109
GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 36480 # GL/glext.h:2110
GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 36481 # GL/glext.h:2111
GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 36482 # GL/glext.h:2112
GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 36483 # GL/glext.h:2113
GL_MAX_TESS_PATCH_COMPONENTS = 36484 # GL/glext.h:2114
GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 36485 # GL/glext.h:2115
GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 36486 # GL/glext.h:2116
GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 36489 # GL/glext.h:2117
GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 36490 # GL/glext.h:2118
GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = 34924 # GL/glext.h:2119
GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 34925 # GL/glext.h:2120
GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 36382 # GL/glext.h:2121
GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 36383 # GL/glext.h:2122
GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 34032 # GL/glext.h:2123
GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 34033 # GL/glext.h:2124
GL_TESS_EVALUATION_SHADER = 36487 # GL/glext.h:2125
GL_TESS_CONTROL_SHADER = 36488 # GL/glext.h:2126
# ARB_texture_buffer_object_rgb32 (GL/glext.h:2129)
# ARB_transform_feedback2 (GL/glext.h:2135)
GL_TRANSFORM_FEEDBACK = 36386 # GL/glext.h:2136
GL_TRANSFORM_FEEDBACK_PAUSED = 36387 # GL/glext.h:2137
GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 36387 # GL/glext.h:2138
GL_TRANSFORM_FEEDBACK_ACTIVE = 36388 # GL/glext.h:2139
GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 36388 # GL/glext.h:2140
GL_TRANSFORM_FEEDBACK_BINDING = 36389 # GL/glext.h:2141
# ARB_transform_feedback3 (GL/glext.h:2144)
GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = 36464 # GL/glext.h:2145
GL_MAX_VERTEX_STREAMS = 36465 # GL/glext.h:2146
# ARB_ES2_compatibility (GL/glext.h:2149)
GL_FIXED = 5132 # GL/glext.h:2150
GL_IMPLEMENTATION_COLOR_READ_TYPE = 35738 # GL/glext.h:2151
GL_IMPLEMENTATION_COLOR_READ_FORMAT = 35739 # GL/glext.h:2152
GL_LOW_FLOAT = 36336 # GL/glext.h:2153
GL_MEDIUM_FLOAT = 36337 # GL/glext.h:2154
GL_HIGH_FLOAT = 36338 # GL/glext.h:2155
GL_LOW_INT = 36339 # GL/glext.h:2156
GL_MEDIUM_INT = 36340 # GL/glext.h:2157
GL_HIGH_INT = 36341 # GL/glext.h:2158
GL_SHADER_COMPILER = 36346 # GL/glext.h:2159
GL_NUM_SHADER_BINARY_FORMATS = 36345 # GL/glext.h:2160
GL_MAX_VERTEX_UNIFORM_VECTORS = 36347 # GL/glext.h:2161
GL_MAX_VARYING_VECTORS = 36348 # GL/glext.h:2162
GL_MAX_FRAGMENT_UNIFORM_VECTORS = 36349 # GL/glext.h:2163
GL_RGB565 = 36194 # GL/glext.h:2164
# ARB_get_program_binary (GL/glext.h:2167)
GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 33367 # GL/glext.h:2168
GL_PROGRAM_BINARY_LENGTH = 34625 # GL/glext.h:2169
GL_NUM_PROGRAM_BINARY_FORMATS = 34814 # GL/glext.h:2170
GL_PROGRAM_BINARY_FORMATS = 34815 # GL/glext.h:2171
# ARB_separate_shader_objects (GL/glext.h:2174)
GL_VERTEX_SHADER_BIT = 1 # GL/glext.h:2175
GL_FRAGMENT_SHADER_BIT = 2 # GL/glext.h:2176
GL_GEOMETRY_SHADER_BIT = 4 # GL/glext.h:2177
GL_TESS_CONTROL_SHADER_BIT = 8 # GL/glext.h:2178
GL_TESS_EVALUATION_SHADER_BIT = 16 # GL/glext.h:2179
GL_ALL_SHADER_BITS = 4294967295 # GL/glext.h:2180
GL_PROGRAM_SEPARABLE = 33368 # GL/glext.h:2181
GL_ACTIVE_PROGRAM = 33369 # GL/glext.h:2182
GL_PROGRAM_PIPELINE_BINDING = 33370 # GL/glext.h:2183
# ARB_shader_precision (GL/glext.h:2186)
# ARB_vertex_attrib_64bit (GL/glext.h:2189)
# ARB_viewport_array (GL/glext.h:2205)
GL_MAX_VIEWPORTS = 33371 # GL/glext.h:2210
GL_VIEWPORT_SUBPIXEL_BITS = 33372 # GL/glext.h:2211
GL_VIEWPORT_BOUNDS_RANGE = 33373 # GL/glext.h:2212
GL_LAYER_PROVOKING_VERTEX = 33374 # GL/glext.h:2213
GL_VIEWPORT_INDEX_PROVOKING_VERTEX = 33375 # GL/glext.h:2214
GL_UNDEFINED_VERTEX = 33376 # GL/glext.h:2215
# ARB_cl_event (GL/glext.h:2221)
GL_SYNC_CL_EVENT_ARB = 33344 # GL/glext.h:2222
GL_SYNC_CL_EVENT_COMPLETE_ARB = 33345 # GL/glext.h:2223
# ARB_debug_output (GL/glext.h:2226)
GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 33346 # GL/glext.h:2227
GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 33347 # GL/glext.h:2228
GL_DEBUG_CALLBACK_FUNCTION_ARB = 33348 # GL/glext.h:2229
GL_DEBUG_CALLBACK_USER_PARAM_ARB = 33349 # GL/glext.h:2230
GL_DEBUG_SOURCE_API_ARB = 33350 # GL/glext.h:2231
GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 33351 # GL/glext.h:2232
GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = 33352 # GL/glext.h:2233
GL_DEBUG_SOURCE_THIRD_PARTY_ARB = 33353 # GL/glext.h:2234
GL_DEBUG_SOURCE_APPLICATION_ARB = 33354 # GL/glext.h:2235
GL_DEBUG_SOURCE_OTHER_ARB = 33355 # GL/glext.h:2236
GL_DEBUG_TYPE_ERROR_ARB = 33356 # GL/glext.h:2237
GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 33357 # GL/glext.h:2238
GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 33358 # GL/glext.h:2239
GL_DEBUG_TYPE_PORTABILITY_ARB = 33359 # GL/glext.h:2240
GL_DEBUG_TYPE_PERFORMANCE_ARB = 33360 # GL/glext.h:2241
GL_DEBUG_TYPE_OTHER_ARB = 33361 # GL/glext.h:2242
GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = 37187 # GL/glext.h:2243
GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = 37188 # GL/glext.h:2244
GL_DEBUG_LOGGED_MESSAGES_ARB = 37189 # GL/glext.h:2245
GL_DEBUG_SEVERITY_HIGH_ARB = 37190 # GL/glext.h:2246
GL_DEBUG_SEVERITY_MEDIUM_ARB = 37191 # GL/glext.h:2247
GL_DEBUG_SEVERITY_LOW_ARB = 37192 # GL/glext.h:2248
# ARB_robustness (GL/glext.h:2251)
GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 4 # GL/glext.h:2253
GL_LOSE_CONTEXT_ON_RESET_ARB = 33362 # GL/glext.h:2254
GL_GUILTY_CONTEXT_RESET_ARB = 33363 # GL/glext.h:2255
GL_INNOCENT_CONTEXT_RESET_ARB = 33364 # GL/glext.h:2256
GL_UNKNOWN_CONTEXT_RESET_ARB = 33365 # GL/glext.h:2257
GL_RESET_NOTIFICATION_STRATEGY_ARB = 33366 # GL/glext.h:2258
GL_NO_RESET_NOTIFICATION_ARB = 33377 # GL/glext.h:2259
# ARB_shader_stencil_export (GL/glext.h:2262)
# ARB_base_instance (GL/glext.h:2265)
# ARB_shading_language_420pack (GL/glext.h:2268)
# ARB_transform_feedback_instanced (GL/glext.h:2271)
# ARB_compressed_texture_pixel_storage (GL/glext.h:2274)
GL_UNPACK_COMPRESSED_BLOCK_WIDTH = 37159 # GL/glext.h:2275
GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = 37160 # GL/glext.h:2276
GL_UNPACK_COMPRESSED_BLOCK_DEPTH = 37161 # GL/glext.h:2277
GL_UNPACK_COMPRESSED_BLOCK_SIZE = 37162 # GL/glext.h:2278
GL_PACK_COMPRESSED_BLOCK_WIDTH = 37163 # GL/glext.h:2279
GL_PACK_COMPRESSED_BLOCK_HEIGHT = 37164 # GL/glext.h:2280
GL_PACK_COMPRESSED_BLOCK_DEPTH = 37165 # GL/glext.h:2281
GL_PACK_COMPRESSED_BLOCK_SIZE = 37166 # GL/glext.h:2282
# ARB_conservative_depth (GL/glext.h:2285)
# ARB_internalformat_query (GL/glext.h:2288)
GL_NUM_SAMPLE_COUNTS = 37760 # GL/glext.h:2289
# ARB_map_buffer_alignment (GL/glext.h:2292)
GL_MIN_MAP_BUFFER_ALIGNMENT = 37052 # GL/glext.h:2293
# ARB_shader_atomic_counters (GL/glext.h:2296)
GL_ATOMIC_COUNTER_BUFFER = 37568 # GL/glext.h:2297
GL_ATOMIC_COUNTER_BUFFER_BINDING = 37569 # GL/glext.h:2298
GL_ATOMIC_COUNTER_BUFFER_START = 37570 # GL/glext.h:2299
GL_ATOMIC_COUNTER_BUFFER_SIZE = 37571 # GL/glext.h:2300
GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 37572 # GL/glext.h:2301
GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 37573 # GL/glext.h:2302
GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 37574 # GL/glext.h:2303
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 37575 # GL/glext.h:2304
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 37576 # GL/glext.h:2305
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 37577 # GL/glext.h:2306
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 37578 # GL/glext.h:2307
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 37579 # GL/glext.h:2308
GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 37580 # GL/glext.h:2309
GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 37581 # GL/glext.h:2310
GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 37582 # GL/glext.h:2311
GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 37583 # GL/glext.h:2312
GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 37584 # GL/glext.h:2313
GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 37585 # GL/glext.h:2314
GL_MAX_VERTEX_ATOMIC_COUNTERS = 37586 # GL/glext.h:2315
GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 37587 # GL/glext.h:2316
GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 37588 # GL/glext.h:2317
GL_MAX_GEOMETRY_ATOMIC_COUNTERS = 37589 # GL/glext.h:2318
GL_MAX_FRAGMENT_ATOMIC_COUNTERS = 37590 # GL/glext.h:2319
GL_MAX_COMBINED_ATOMIC_COUNTERS = 37591 # GL/glext.h:2320
GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 37592 # GL/glext.h:2321
GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 37596 # GL/glext.h:2322
GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = 37593 # GL/glext.h:2323
GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 37594 # GL/glext.h:2324
GL_UNSIGNED_INT_ATOMIC_COUNTER = 37595 # GL/glext.h:2325
# ARB_shader_image_load_store (GL/glext.h:2328)
GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 1 # GL/glext.h:2329
GL_ELEMENT_ARRAY_BARRIER_BIT = 2 # GL/glext.h:2330
GL_UNIFORM_BARRIER_BIT = 4 # GL/glext.h:2331
GL_TEXTURE_FETCH_BARRIER_BIT = 8 # GL/glext.h:2332
GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = 32 # GL/glext.h:2333
GL_COMMAND_BARRIER_BIT = 64 # GL/glext.h:2334
GL_PIXEL_BUFFER_BARRIER_BIT = 128 # GL/glext.h:2335
GL_TEXTURE_UPDATE_BARRIER_BIT = 256 # GL/glext.h:2336
GL_BUFFER_UPDATE_BARRIER_BIT = 512 # GL/glext.h:2337
GL_FRAMEBUFFER_BARRIER_BIT = 1024 # GL/glext.h:2338
GL_TRANSFORM_FEEDBACK_BARRIER_BIT = 2048 # GL/glext.h:2339
GL_ATOMIC_COUNTER_BARRIER_BIT = 4096 # GL/glext.h:2340
GL_ALL_BARRIER_BITS = 4294967295 # GL/glext.h:2341
GL_MAX_IMAGE_UNITS = 36664 # GL/glext.h:2342
GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 36665 # GL/glext.h:2343
GL_IMAGE_BINDING_NAME = 36666 # GL/glext.h:2344
GL_IMAGE_BINDING_LEVEL = 36667 # GL/glext.h:2345
GL_IMAGE_BINDING_LAYERED = 36668 # GL/glext.h:2346
GL_IMAGE_BINDING_LAYER = 36669 # GL/glext.h:2347
GL_IMAGE_BINDING_ACCESS = 36670 # GL/glext.h:2348
GL_IMAGE_1D = 36940 # GL/glext.h:2349
GL_IMAGE_2D = 36941 # GL/glext.h:2350
GL_IMAGE_3D = 36942 # GL/glext.h:2351
GL_IMAGE_2D_RECT = 36943 # GL/glext.h:2352
GL_IMAGE_CUBE = 36944 # GL/glext.h:2353
GL_IMAGE_BUFFER = 36945 # GL/glext.h:2354
GL_IMAGE_1D_ARRAY = 36946 # GL/glext.h:2355
GL_IMAGE_2D_ARRAY = 36947 # GL/glext.h:2356
GL_IMAGE_CUBE_MAP_ARRAY = 36948 # GL/glext.h:2357
GL_IMAGE_2D_MULTISAMPLE = 36949 # GL/glext.h:2358
GL_IMAGE_2D_MULTISAMPLE_ARRAY = 36950 # GL/glext.h:2359
GL_INT_IMAGE_1D = 36951 # GL/glext.h:2360
GL_INT_IMAGE_2D = 36952 # GL/glext.h:2361
GL_INT_IMAGE_3D = 36953 # GL/glext.h:2362
GL_INT_IMAGE_2D_RECT = 36954 # GL/glext.h:2363
GL_INT_IMAGE_CUBE = 36955 # GL/glext.h:2364
GL_INT_IMAGE_BUFFER = 36956 # GL/glext.h:2365
GL_INT_IMAGE_1D_ARRAY = 36957 # GL/glext.h:2366
GL_INT_IMAGE_2D_ARRAY = 36958 # GL/glext.h:2367
GL_INT_IMAGE_CUBE_MAP_ARRAY = 36959 # GL/glext.h:2368
GL_INT_IMAGE_2D_MULTISAMPLE = 36960 # GL/glext.h:2369
GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 36961 # GL/glext.h:2370
GL_UNSIGNED_INT_IMAGE_1D = 36962 # GL/glext.h:2371
GL_UNSIGNED_INT_IMAGE_2D = 36963 # GL/glext.h:2372
GL_UNSIGNED_INT_IMAGE_3D = 36964 # GL/glext.h:2373
GL_UNSIGNED_INT_IMAGE_2D_RECT = 36965 # GL/glext.h:2374
GL_UNSIGNED_INT_IMAGE_CUBE = 36966 # GL/glext.h:2375
GL_UNSIGNED_INT_IMAGE_BUFFER = 36967 # GL/glext.h:2376
GL_UNSIGNED_INT_IMAGE_1D_ARRAY = 36968 # GL/glext.h:2377
GL_UNSIGNED_INT_IMAGE_2D_ARRAY = 36969 # GL/glext.h:2378
GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 36970 # GL/glext.h:2379
GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 36971 # GL/glext.h:2380
GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 36972 # GL/glext.h:2381
GL_MAX_IMAGE_SAMPLES = 36973 # GL/glext.h:2382
GL_IMAGE_BINDING_FORMAT = 36974 # GL/glext.h:2383
GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 37063 # GL/glext.h:2384
GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 37064 # GL/glext.h:2385
GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 37065 # GL/glext.h:2386
GL_MAX_VERTEX_IMAGE_UNIFORMS = 37066 # GL/glext.h:2387
GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 37067 # GL/glext.h:2388
GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 37068 # GL/glext.h:2389
GL_MAX_GEOMETRY_IMAGE_UNIFORMS = 37069 # GL/glext.h:2390
GL_MAX_FRAGMENT_IMAGE_UNIFORMS = 37070 # GL/glext.h:2391
GL_MAX_COMBINED_IMAGE_UNIFORMS = 37071 # GL/glext.h:2392
# ARB_shading_language_packing (GL/glext.h:2395)
# ARB_texture_storage (GL/glext.h:2398)
GL_TEXTURE_IMMUTABLE_FORMAT = 37167 # GL/glext.h:2399
# EXT_abgr (GL/glext.h:2402)
GL_ABGR_EXT = 32768 # GL/glext.h:2403
# EXT_blend_color (GL/glext.h:2406)
GL_CONSTANT_COLOR_EXT = 32769 # GL/glext.h:2407
GL_ONE_MINUS_CONSTANT_COLOR_EXT = 32770 # GL/glext.h:2408
GL_CONSTANT_ALPHA_EXT = 32771 # GL/glext.h:2409
GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 32772 # GL/glext.h:2410
GL_BLEND_COLOR_EXT = 32773 # GL/glext.h:2411
# EXT_polygon_offset (GL/glext.h:2414)
GL_POLYGON_OFFSET_EXT = 32823 # GL/glext.h:2415
GL_POLYGON_OFFSET_FACTOR_EXT = 32824 # GL/glext.h:2416
GL_POLYGON_OFFSET_BIAS_EXT = 32825 # GL/glext.h:2417
# EXT_texture (GL/glext.h:2420)
GL_ALPHA4_EXT = 32827 # GL/glext.h:2421
GL_ALPHA8_EXT = 32828 # GL/glext.h:2422
GL_ALPHA12_EXT = 32829 # GL/glext.h:2423
GL_ALPHA16_EXT = 32830 # GL/glext.h:2424
GL_LUMINANCE4_EXT = 32831 # GL/glext.h:2425
GL_LUMINANCE8_EXT = 32832 # GL/glext.h:2426
GL_LUMINANCE12_EXT = 32833 # GL/glext.h:2427
GL_LUMINANCE16_EXT = 32834 # GL/glext.h:2428
GL_LUMINANCE4_ALPHA4_EXT = 32835 # GL/glext.h:2429
GL_LUMINANCE6_ALPHA2_EXT = 32836 # GL/glext.h:2430
GL_LUMINANCE8_ALPHA8_EXT = 32837 # GL/glext.h:2431
GL_LUMINANCE12_ALPHA4_EXT = 32838 # GL/glext.h:2432
GL_LUMINANCE12_ALPHA12_EXT = 32839 # GL/glext.h:2433
GL_LUMINANCE16_ALPHA16_EXT = 32840 # GL/glext.h:2434
GL_INTENSITY_EXT = 32841 # GL/glext.h:2435
GL_INTENSITY4_EXT = 32842 # GL/glext.h:2436
GL_INTENSITY8_EXT = 32843 # GL/glext.h:2437
GL_INTENSITY12_EXT = 32844 # GL/glext.h:2438
GL_INTENSITY16_EXT = 32845 # GL/glext.h:2439
GL_RGB2_EXT = 32846 # GL/glext.h:2440
GL_RGB4_EXT = 32847 # GL/glext.h:2441
GL_RGB5_EXT = 32848 # GL/glext.h:2442
GL_RGB8_EXT = 32849 # GL/glext.h:2443
GL_RGB10_EXT = 32850 # GL/glext.h:2444
GL_RGB12_EXT = 32851 # GL/glext.h:2445
GL_RGB16_EXT = 32852 # GL/glext.h:2446
GL_RGBA2_EXT = 32853 # GL/glext.h:2447
GL_RGBA4_EXT = 32854 # GL/glext.h:2448
GL_RGB5_A1_EXT = 32855 # GL/glext.h:2449
GL_RGBA8_EXT = 32856 # GL/glext.h:2450
GL_RGB10_A2_EXT = 32857 # GL/glext.h:2451
GL_RGBA12_EXT = 32858 # GL/glext.h:2452
GL_RGBA16_EXT = 32859 # GL/glext.h:2453
GL_TEXTURE_RED_SIZE_EXT = 32860 # GL/glext.h:2454
GL_TEXTURE_GREEN_SIZE_EXT = 32861 # GL/glext.h:2455
GL_TEXTURE_BLUE_SIZE_EXT = 32862 # GL/glext.h:2456
GL_TEXTURE_ALPHA_SIZE_EXT = 32863 # GL/glext.h:2457
GL_TEXTURE_LUMINANCE_SIZE_EXT = 32864 # GL/glext.h:2458
GL_TEXTURE_INTENSITY_SIZE_EXT = 32865 # GL/glext.h:2459
GL_REPLACE_EXT = 32866 # GL/glext.h:2460
GL_PROXY_TEXTURE_1D_EXT = 32867 # GL/glext.h:2461
GL_PROXY_TEXTURE_2D_EXT = 32868 # GL/glext.h:2462
GL_TEXTURE_TOO_LARGE_EXT = 32869 # GL/glext.h:2463
# EXT_texture3D (GL/glext.h:2466)
GL_PACK_SKIP_IMAGES_EXT = 32875 # GL/glext.h:2467
GL_PACK_IMAGE_HEIGHT_EXT = 32876 # GL/glext.h:2468
GL_UNPACK_SKIP_IMAGES_EXT = 32877 # GL/glext.h:2469
GL_UNPACK_IMAGE_HEIGHT_EXT = 32878 # GL/glext.h:2470
GL_TEXTURE_3D_EXT = 32879 # GL/glext.h:2471
GL_PROXY_TEXTURE_3D_EXT = 32880 # GL/glext.h:2472
GL_TEXTURE_DEPTH_EXT = 32881 # GL/glext.h:2473
GL_TEXTURE_WRAP_R_EXT = 32882 # GL/glext.h:2474
GL_MAX_3D_TEXTURE_SIZE_EXT = 32883 # GL/glext.h:2475
# SGIS_texture_filter4 (GL/glext.h:2478)
GL_FILTER4_SGIS = 33094 # GL/glext.h:2479
GL_TEXTURE_FILTER4_SIZE_SGIS = 33095 # GL/glext.h:2480
# EXT_subtexture (GL/glext.h:2483)
# EXT_copy_texture (GL/glext.h:2486)
# EXT_histogram (GL/glext.h:2489)
GL_HISTOGRAM_EXT = 32804 # GL/glext.h:2490
GL_PROXY_HISTOGRAM_EXT = 32805 # GL/glext.h:2491
GL_HISTOGRAM_WIDTH_EXT = 32806 # GL/glext.h:2492
GL_HISTOGRAM_FORMAT_EXT = 32807 # GL/glext.h:2493
GL_HISTOGRAM_RED_SIZE_EXT = 32808 # GL/glext.h:2494
GL_HISTOGRAM_GREEN_SIZE_EXT = 32809 # GL/glext.h:2495
GL_HISTOGRAM_BLUE_SIZE_EXT = 32810 # GL/glext.h:2496
GL_HISTOGRAM_ALPHA_SIZE_EXT = 32811 # GL/glext.h:2497
GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 32812 # GL/glext.h:2498
GL_HISTOGRAM_SINK_EXT = 32813 # GL/glext.h:2499
GL_MINMAX_EXT = 32814 # GL/glext.h:2500
GL_MINMAX_FORMAT_EXT = 32815 # GL/glext.h:2501
GL_MINMAX_SINK_EXT = 32816 # GL/glext.h:2502
GL_TABLE_TOO_LARGE_EXT = 32817 # GL/glext.h:2503
# EXT_convolution (GL/glext.h:2506)
GL_CONVOLUTION_1D_EXT = 32784 # GL/glext.h:2507
GL_CONVOLUTION_2D_EXT = 32785 # GL/glext.h:2508
GL_SEPARABLE_2D_EXT = 32786 # GL/glext.h:2509
GL_CONVOLUTION_BORDER_MODE_EXT = 32787 # GL/glext.h:2510
GL_CONVOLUTION_FILTER_SCALE_EXT = 32788 # GL/glext.h:2511
GL_CONVOLUTION_FILTER_BIAS_EXT = 32789 # GL/glext.h:2512
GL_REDUCE_EXT = 32790 # GL/glext.h:2513
GL_CONVOLUTION_FORMAT_EXT = 32791 # GL/glext.h:2514
GL_CONVOLUTION_WIDTH_EXT = 32792 # GL/glext.h:2515
GL_CONVOLUTION_HEIGHT_EXT = 32793 # GL/glext.h:2516
GL_MAX_CONVOLUTION_WIDTH_EXT = 32794 # GL/glext.h:2517
GL_MAX_CONVOLUTION_HEIGHT_EXT = 32795 # GL/glext.h:2518
GL_POST_CONVOLUTION_RED_SCALE_EXT = 32796 # GL/glext.h:2519
GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 32797 # GL/glext.h:2520
GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 32798 # GL/glext.h:2521
GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 32799 # GL/glext.h:2522
GL_POST_CONVOLUTION_RED_BIAS_EXT = 32800 # GL/glext.h:2523
GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 32801 # GL/glext.h:2524
GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 32802 # GL/glext.h:2525
GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 32803 # GL/glext.h:2526
# SGI_color_matrix (GL/glext.h:2529)
GL_COLOR_MATRIX_SGI = 32945 # GL/glext.h:2530
GL_COLOR_MATRIX_STACK_DEPTH_SGI = 32946 # GL/glext.h:2531
GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 32947 # GL/glext.h:2532
GL_POST_COLOR_MATRIX_RED_SCALE_SGI = 32948 # GL/glext.h:2533
GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 32949 # GL/glext.h:2534
GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 32950 # GL/glext.h:2535
GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 32951 # GL/glext.h:2536
GL_POST_COLOR_MATRIX_RED_BIAS_SGI = 32952 # GL/glext.h:2537
GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 32953 # GL/glext.h:2538
GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 32954 # GL/glext.h:2539
GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 32955 # GL/glext.h:2540
# SGI_color_table (GL/glext.h:2543)
GL_COLOR_TABLE_SGI = 32976 # GL/glext.h:2544
GL_POST_CONVOLUTION_COLOR_TABLE_SGI = 32977 # GL/glext.h:2545
GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 32978 # GL/glext.h:2546
GL_PROXY_COLOR_TABLE_SGI = 32979 # GL/glext.h:2547
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 32980 # GL/glext.h:2548
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 32981 # GL/glext.h:2549
GL_COLOR_TABLE_SCALE_SGI = 32982 # GL/glext.h:2550
GL_COLOR_TABLE_BIAS_SGI = 32983 # GL/glext.h:2551
GL_COLOR_TABLE_FORMAT_SGI = 32984 # GL/glext.h:2552
GL_COLOR_TABLE_WIDTH_SGI = 32985 # GL/glext.h:2553
GL_COLOR_TABLE_RED_SIZE_SGI = 32986 # GL/glext.h:2554
GL_COLOR_TABLE_GREEN_SIZE_SGI = 32987 # GL/glext.h:2555
GL_COLOR_TABLE_BLUE_SIZE_SGI = 32988 # GL/glext.h:2556
GL_COLOR_TABLE_ALPHA_SIZE_SGI = 32989 # GL/glext.h:2557
GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = 32990 # GL/glext.h:2558
GL_COLOR_TABLE_INTENSITY_SIZE_SGI = 32991 # GL/glext.h:2559
# SGIS_pixel_texture (GL/glext.h:2562)
GL_PIXEL_TEXTURE_SGIS = 33619 # GL/glext.h:2563
GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 33620 # GL/glext.h:2564
GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 33621 # GL/glext.h:2565
GL_PIXEL_GROUP_COLOR_SGIS = 33622 # GL/glext.h:2566
# SGIX_pixel_texture (GL/glext.h:2569)
GL_PIXEL_TEX_GEN_SGIX = 33081 # GL/glext.h:2570
GL_PIXEL_TEX_GEN_MODE_SGIX = 33579 # GL/glext.h:2571
# SGIS_texture4D (GL/glext.h:2574)
GL_PACK_SKIP_VOLUMES_SGIS = 33072 # GL/glext.h:2575
GL_PACK_IMAGE_DEPTH_SGIS = 33073 # GL/glext.h:2576
GL_UNPACK_SKIP_VOLUMES_SGIS = 33074 # GL/glext.h:2577
GL_UNPACK_IMAGE_DEPTH_SGIS = 33075 # GL/glext.h:2578
GL_TEXTURE_4D_SGIS = 33076 # GL/glext.h:2579
GL_PROXY_TEXTURE_4D_SGIS = 33077 # GL/glext.h:2580
GL_TEXTURE_4DSIZE_SGIS = 33078 # GL/glext.h:2581
GL_TEXTURE_WRAP_Q_SGIS = 33079 # GL/glext.h:2582
GL_MAX_4D_TEXTURE_SIZE_SGIS = 33080 # GL/glext.h:2583
GL_TEXTURE_4D_BINDING_SGIS = 33103 # GL/glext.h:2584
# SGI_texture_color_table (GL/glext.h:2587)
GL_TEXTURE_COLOR_TABLE_SGI = 32956 # GL/glext.h:2588
GL_PROXY_TEXTURE_COLOR_TABLE_SGI = 32957 # GL/glext.h:2589
# EXT_cmyka (GL/glext.h:2592)
GL_CMYK_EXT = 32780 # GL/glext.h:2593
GL_CMYKA_EXT = 32781 # GL/glext.h:2594
GL_PACK_CMYK_HINT_EXT = 32782 # GL/glext.h:2595
GL_UNPACK_CMYK_HINT_EXT = 32783 # GL/glext.h:2596
# EXT_texture_object (GL/glext.h:2599)
GL_TEXTURE_PRIORITY_EXT = 32870 # GL/glext.h:2600
GL_TEXTURE_RESIDENT_EXT = 32871 # GL/glext.h:2601
GL_TEXTURE_1D_BINDING_EXT = 32872 # GL/glext.h:2602
GL_TEXTURE_2D_BINDING_EXT = 32873 # GL/glext.h:2603
GL_TEXTURE_3D_BINDING_EXT = 32874 # GL/glext.h:2604
# SGIS_detail_texture (GL/glext.h:2607)
GL_DETAIL_TEXTURE_2D_SGIS = 32917 # GL/glext.h:2608
GL_DETAIL_TEXTURE_2D_BINDING_SGIS = 32918 # GL/glext.h:2609
GL_LINEAR_DETAIL_SGIS = 32919 # GL/glext.h:2610
GL_LINEAR_DETAIL_ALPHA_SGIS = 32920 # GL/glext.h:2611
GL_LINEAR_DETAIL_COLOR_SGIS = 32921 # GL/glext.h:2612
GL_DETAIL_TEXTURE_LEVEL_SGIS = 32922 # GL/glext.h:2613
GL_DETAIL_TEXTURE_MODE_SGIS = 32923 # GL/glext.h:2614
GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 32924 # GL/glext.h:2615
# SGIS_sharpen_texture (GL/glext.h:2618)
GL_LINEAR_SHARPEN_SGIS = 32941 # GL/glext.h:2619
GL_LINEAR_SHARPEN_ALPHA_SGIS = 32942 # GL/glext.h:2620
GL_LINEAR_SHARPEN_COLOR_SGIS = 32943 # GL/glext.h:2621
GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 32944 # GL/glext.h:2622
# EXT_packed_pixels (GL/glext.h:2625)
GL_UNSIGNED_BYTE_3_3_2_EXT = 32818 # GL/glext.h:2626
GL_UNSIGNED_SHORT_4_4_4_4_EXT = 32819 # GL/glext.h:2627
GL_UNSIGNED_SHORT_5_5_5_1_EXT = 32820 # GL/glext.h:2628
GL_UNSIGNED_INT_8_8_8_8_EXT = 32821 # GL/glext.h:2629
GL_UNSIGNED_INT_10_10_10_2_EXT = 32822 # GL/glext.h:2630
# SGIS_texture_lod (GL/glext.h:2633)
GL_TEXTURE_MIN_LOD_SGIS = 33082 # GL/glext.h:2634
GL_TEXTURE_MAX_LOD_SGIS = 33083 # GL/glext.h:2635
GL_TEXTURE_BASE_LEVEL_SGIS = 33084 # GL/glext.h:2636
GL_TEXTURE_MAX_LEVEL_SGIS = 33085 # GL/glext.h:2637
# SGIS_multisample (GL/glext.h:2640)
GL_MULTISAMPLE_SGIS = 32925 # GL/glext.h:2641
GL_SAMPLE_ALPHA_TO_MASK_SGIS = 32926 # GL/glext.h:2642
GL_SAMPLE_ALPHA_TO_ONE_SGIS = 32927 # GL/glext.h:2643
GL_SAMPLE_MASK_SGIS = 32928 # GL/glext.h:2644
GL_1PASS_SGIS = 32929 # GL/glext.h:2645
GL_2PASS_0_SGIS = 32930 # GL/glext.h:2646
GL_2PASS_1_SGIS = 32931 # GL/glext.h:2647
GL_4PASS_0_SGIS = 32932 # GL/glext.h:2648
GL_4PASS_1_SGIS = 32933 # GL/glext.h:2649
GL_4PASS_2_SGIS = 32934 # GL/glext.h:2650
GL_4PASS_3_SGIS = 32935 # GL/glext.h:2651
GL_SAMPLE_BUFFERS_SGIS = 32936 # GL/glext.h:2652
GL_SAMPLES_SGIS = 32937 # GL/glext.h:2653
GL_SAMPLE_MASK_VALUE_SGIS = 32938 # GL/glext.h:2654
GL_SAMPLE_MASK_INVERT_SGIS = 32939 # GL/glext.h:2655
GL_SAMPLE_PATTERN_SGIS = 32940 # GL/glext.h:2656
# EXT_rescale_normal (GL/glext.h:2659)
GL_RESCALE_NORMAL_EXT = 32826 # GL/glext.h:2660
# EXT_vertex_array (GL/glext.h:2663)
GL_VERTEX_ARRAY_EXT = 32884 # GL/glext.h:2664
GL_NORMAL_ARRAY_EXT = 32885 # GL/glext.h:2665
GL_COLOR_ARRAY_EXT = 32886 # GL/glext.h:2666
GL_INDEX_ARRAY_EXT = 32887 # GL/glext.h:2667
GL_TEXTURE_COORD_ARRAY_EXT = 32888 # GL/glext.h:2668
GL_EDGE_FLAG_ARRAY_EXT = 32889 # GL/glext.h:2669
GL_VERTEX_ARRAY_SIZE_EXT = 32890 # GL/glext.h:2670
GL_VERTEX_ARRAY_TYPE_EXT = 32891 # GL/glext.h:2671
GL_VERTEX_ARRAY_STRIDE_EXT = 32892 # GL/glext.h:2672
GL_VERTEX_ARRAY_COUNT_EXT = 32893 # GL/glext.h:2673
GL_NORMAL_ARRAY_TYPE_EXT = 32894 # GL/glext.h:2674
GL_NORMAL_ARRAY_STRIDE_EXT = 32895 # GL/glext.h:2675
GL_NORMAL_ARRAY_COUNT_EXT = 32896 # GL/glext.h:2676
GL_COLOR_ARRAY_SIZE_EXT = 32897 # GL/glext.h:2677
GL_COLOR_ARRAY_TYPE_EXT = 32898 # GL/glext.h:2678
GL_COLOR_ARRAY_STRIDE_EXT = 32899 # GL/glext.h:2679
GL_COLOR_ARRAY_COUNT_EXT = 32900 # GL/glext.h:2680
GL_INDEX_ARRAY_TYPE_EXT = 32901 # GL/glext.h:2681
GL_INDEX_ARRAY_STRIDE_EXT = 32902 # GL/glext.h:2682
GL_INDEX_ARRAY_COUNT_EXT = 32903 # GL/glext.h:2683
GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 32904 # GL/glext.h:2684
GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 32905 # GL/glext.h:2685
GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 32906 # GL/glext.h:2686
GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 32907 # GL/glext.h:2687
GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 32908 # GL/glext.h:2688
GL_EDGE_FLAG_ARRAY_COUNT_EXT = 32909 # GL/glext.h:2689
GL_VERTEX_ARRAY_POINTER_EXT = 32910 # GL/glext.h:2690
GL_NORMAL_ARRAY_POINTER_EXT = 32911 # GL/glext.h:2691
GL_COLOR_ARRAY_POINTER_EXT = 32912 # GL/glext.h:2692
GL_INDEX_ARRAY_POINTER_EXT = 32913 # GL/glext.h:2693
GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 32914 # GL/glext.h:2694
GL_EDGE_FLAG_ARRAY_POINTER_EXT = 32915 # GL/glext.h:2695
# EXT_misc_attribute (GL/glext.h:2698)
# SGIS_generate_mipmap (GL/glext.h:2701)
GL_GENERATE_MIPMAP_SGIS = 33169 # GL/glext.h:2702
GL_GENERATE_MIPMAP_HINT_SGIS = 33170 # GL/glext.h:2703
# SGIX_clipmap (GL/glext.h:2706)
GL_LINEAR_CLIPMAP_LINEAR_SGIX = 33136 # GL/glext.h:2707
GL_TEXTURE_CLIPMAP_CENTER_SGIX = 33137 # GL/glext.h:2708
GL_TEXTURE_CLIPMAP_FRAME_SGIX = 33138 # GL/glext.h:2709
GL_TEXTURE_CLIPMAP_OFFSET_SGIX = 33139 # GL/glext.h:2710
GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 33140 # GL/glext.h:2711
GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 33141 # GL/glext.h:2712
GL_TEXTURE_CLIPMAP_DEPTH_SGIX = 33142 # GL/glext.h:2713
GL_MAX_CLIPMAP_DEPTH_SGIX = 33143 # GL/glext.h:2714
GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 33144 # GL/glext.h:2715
GL_NEAREST_CLIPMAP_NEAREST_SGIX = 33869 # GL/glext.h:2716
GL_NEAREST_CLIPMAP_LINEAR_SGIX = 33870 # GL/glext.h:2717
GL_LINEAR_CLIPMAP_NEAREST_SGIX = 33871 # GL/glext.h:2718
# SGIX_shadow (GL/glext.h:2721)
GL_TEXTURE_COMPARE_SGIX = 33178 # GL/glext.h:2722
GL_TEXTURE_COMPARE_OPERATOR_SGIX = 33179 # GL/glext.h:2723
GL_TEXTURE_LEQUAL_R_SGIX = 33180 # GL/glext.h:2724
GL_TEXTURE_GEQUAL_R_SGIX = 33181 # GL/glext.h:2725
# SGIS_texture_edge_clamp (GL/glext.h:2728)
GL_CLAMP_TO_EDGE_SGIS = 33071 # GL/glext.h:2729
# SGIS_texture_border_clamp (GL/glext.h:2732)
GL_CLAMP_TO_BORDER_SGIS = 33069 # GL/glext.h:2733
# EXT_blend_minmax (GL/glext.h:2736)
GL_FUNC_ADD_EXT = 32774 # GL/glext.h:2737
GL_MIN_EXT = 32775 # GL/glext.h:2738
GL_MAX_EXT = 32776 # GL/glext.h:2739
GL_BLEND_EQUATION_EXT = 32777 # GL/glext.h:2740
# EXT_blend_subtract (GL/glext.h:2743)
GL_FUNC_SUBTRACT_EXT = 32778 # GL/glext.h:2744
GL_FUNC_REVERSE_SUBTRACT_EXT = 32779 # GL/glext.h:2745
# EXT_blend_logic_op (GL/glext.h:2748)
# SGIX_interlace (GL/glext.h:2751)
GL_INTERLACE_SGIX = 32916 # GL/glext.h:2752
# SGIX_pixel_tiles (GL/glext.h:2755)
GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 33086 # GL/glext.h:2756
GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = 33087 # GL/glext.h:2757
GL_PIXEL_TILE_WIDTH_SGIX = 33088 # GL/glext.h:2758
GL_PIXEL_TILE_HEIGHT_SGIX = 33089 # GL/glext.h:2759
GL_PIXEL_TILE_GRID_WIDTH_SGIX = 33090 # GL/glext.h:2760
GL_PIXEL_TILE_GRID_HEIGHT_SGIX = 33091 # GL/glext.h:2761
GL_PIXEL_TILE_GRID_DEPTH_SGIX = 33092 # GL/glext.h:2762
GL_PIXEL_TILE_CACHE_SIZE_SGIX = 33093 # GL/glext.h:2763
# SGIS_texture_select (GL/glext.h:2766)
GL_DUAL_ALPHA4_SGIS = 33040 # GL/glext.h:2767
GL_DUAL_ALPHA8_SGIS = 33041 # GL/glext.h:2768
GL_DUAL_ALPHA12_SGIS = 33042 # GL/glext.h:2769
GL_DUAL_ALPHA16_SGIS = 33043 # GL/glext.h:2770
GL_DUAL_LUMINANCE4_SGIS = 33044 # GL/glext.h:2771
GL_DUAL_LUMINANCE8_SGIS = 33045 # GL/glext.h:2772
GL_DUAL_LUMINANCE12_SGIS = 33046 # GL/glext.h:2773
GL_DUAL_LUMINANCE16_SGIS = 33047 # GL/glext.h:2774
GL_DUAL_INTENSITY4_SGIS = 33048 # GL/glext.h:2775
GL_DUAL_INTENSITY8_SGIS = 33049 # GL/glext.h:2776
GL_DUAL_INTENSITY12_SGIS = 33050 # GL/glext.h:2777
GL_DUAL_INTENSITY16_SGIS = 33051 # GL/glext.h:2778
GL_DUAL_LUMINANCE_ALPHA4_SGIS = 33052 # GL/glext.h:2779
GL_DUAL_LUMINANCE_ALPHA8_SGIS = 33053 # GL/glext.h:2780
GL_QUAD_ALPHA4_SGIS = 33054 # GL/glext.h:2781
GL_QUAD_ALPHA8_SGIS = 33055 # GL/glext.h:2782
GL_QUAD_LUMINANCE4_SGIS = 33056 # GL/glext.h:2783
GL_QUAD_LUMINANCE8_SGIS = 33057 # GL/glext.h:2784
GL_QUAD_INTENSITY4_SGIS = 33058 # GL/glext.h:2785
GL_QUAD_INTENSITY8_SGIS = 33059 # GL/glext.h:2786
GL_DUAL_TEXTURE_SELECT_SGIS = 33060 # GL/glext.h:2787
GL_QUAD_TEXTURE_SELECT_SGIS = 33061 # GL/glext.h:2788
# SGIX_sprite (GL/glext.h:2791)
GL_SPRITE_SGIX = 33096 # GL/glext.h:2792
GL_SPRITE_MODE_SGIX = 33097 # GL/glext.h:2793
GL_SPRITE_AXIS_SGIX = 33098 # GL/glext.h:2794
GL_SPRITE_TRANSLATION_SGIX = 33099 # GL/glext.h:2795
GL_SPRITE_AXIAL_SGIX = 33100 # GL/glext.h:2796
GL_SPRITE_OBJECT_ALIGNED_SGIX = 33101 # GL/glext.h:2797
GL_SPRITE_EYE_ALIGNED_SGIX = 33102 # GL/glext.h:2798
# SGIX_texture_multi_buffer (GL/glext.h:2801)
GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = 33070 # GL/glext.h:2802
# EXT_point_parameters (GL/glext.h:2805)
GL_POINT_SIZE_MIN_EXT = 33062 # GL/glext.h:2806
GL_POINT_SIZE_MAX_EXT = 33063 # GL/glext.h:2807
GL_POINT_FADE_THRESHOLD_SIZE_EXT = 33064 # GL/glext.h:2808
GL_DISTANCE_ATTENUATION_EXT = 33065 # GL/glext.h:2809
# SGIS_point_parameters (GL/glext.h:2812)
GL_POINT_SIZE_MIN_SGIS = 33062 # GL/glext.h:2813
GL_POINT_SIZE_MAX_SGIS = 33063 # GL/glext.h:2814
GL_POINT_FADE_THRESHOLD_SIZE_SGIS = 33064 # GL/glext.h:2815
GL_DISTANCE_ATTENUATION_SGIS = 33065 # GL/glext.h:2816
# SGIX_instruments (GL/glext.h:2819)
GL_INSTRUMENT_BUFFER_POINTER_SGIX = 33152 # GL/glext.h:2820
GL_INSTRUMENT_MEASUREMENTS_SGIX = 33153 # GL/glext.h:2821
# SGIX_texture_scale_bias (GL/glext.h:2824)
GL_POST_TEXTURE_FILTER_BIAS_SGIX = 33145 # GL/glext.h:2825
GL_POST_TEXTURE_FILTER_SCALE_SGIX = 33146 # GL/glext.h:2826
GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 33147 # GL/glext.h:2827
GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 33148 # GL/glext.h:2828
# SGIX_framezoom (GL/glext.h:2831)
GL_FRAMEZOOM_SGIX = 33163 # GL/glext.h:2832
GL_FRAMEZOOM_FACTOR_SGIX = 33164 # GL/glext.h:2833
GL_MAX_FRAMEZOOM_FACTOR_SGIX = 33165 # GL/glext.h:2834
# SGIX_tag_sample_buffer (GL/glext.h:2837)
# FfdMaskSGIX (GL/glext.h:2840)
GL_TEXTURE_DEFORMATION_BIT_SGIX = 1 # GL/glext.h:2841
GL_GEOMETRY_DEFORMATION_BIT_SGIX = 2 # GL/glext.h:2842
# SGIX_polynomial_ffd (GL/glext.h:2845)
GL_GEOMETRY_DEFORMATION_SGIX = 33172 # GL/glext.h:2846
GL_TEXTURE_DEFORMATION_SGIX = 33173 # GL/glext.h:2847
GL_DEFORMATIONS_MASK_SGIX = 33174 # GL/glext.h:2848
GL_MAX_DEFORMATION_ORDER_SGIX = 33175 # GL/glext.h:2849
# SGIX_reference_plane (GL/glext.h:2852)
GL_REFERENCE_PLANE_SGIX = 33149 # GL/glext.h:2853
GL_REFERENCE_PLANE_EQUATION_SGIX = 33150 # GL/glext.h:2854
# SGIX_flush_raster (GL/glext.h:2857)
# SGIX_depth_texture (GL/glext.h:2860)
GL_DEPTH_COMPONENT16_SGIX = 33189 # GL/glext.h:2861
GL_DEPTH_COMPONENT24_SGIX = 33190 # GL/glext.h:2862
GL_DEPTH_COMPONENT32_SGIX = 33191 # GL/glext.h:2863
# SGIS_fog_function (GL/glext.h:2866)
GL_FOG_FUNC_SGIS = 33066 # GL/glext.h:2867
GL_FOG_FUNC_POINTS_SGIS = 33067 # GL/glext.h:2868
GL_MAX_FOG_FUNC_POINTS_SGIS = 33068 # GL/glext.h:2869
# SGIX_fog_offset (GL/glext.h:2872)
GL_FOG_OFFSET_SGIX = 33176 # GL/glext.h:2873
GL_FOG_OFFSET_VALUE_SGIX = 33177 # GL/glext.h:2874
# HP_image_transform (GL/glext.h:2877)
GL_IMAGE_SCALE_X_HP = 33109 # GL/glext.h:2878
GL_IMAGE_SCALE_Y_HP = 33110 # GL/glext.h:2879
GL_IMAGE_TRANSLATE_X_HP = 33111 # GL/glext.h:2880
GL_IMAGE_TRANSLATE_Y_HP = 33112 # GL/glext.h:2881
GL_IMAGE_ROTATE_ANGLE_HP = 33113 # GL/glext.h:2882
GL_IMAGE_ROTATE_ORIGIN_X_HP = 33114 # GL/glext.h:2883
GL_IMAGE_ROTATE_ORIGIN_Y_HP = 33115 # GL/glext.h:2884
GL_IMAGE_MAG_FILTER_HP = 33116 # GL/glext.h:2885
GL_IMAGE_MIN_FILTER_HP = 33117 # GL/glext.h:2886
GL_IMAGE_CUBIC_WEIGHT_HP = 33118 # GL/glext.h:2887
GL_CUBIC_HP = 33119 # GL/glext.h:2888
GL_AVERAGE_HP = 33120 # GL/glext.h:2889
GL_IMAGE_TRANSFORM_2D_HP = 33121 # GL/glext.h:2890
GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 33122 # GL/glext.h:2891
GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 33123 # GL/glext.h:2892
# HP_convolution_border_modes (GL/glext.h:2895)
GL_IGNORE_BORDER_HP = 33104 # GL/glext.h:2896
GL_CONSTANT_BORDER_HP = 33105 # GL/glext.h:2897
GL_REPLICATE_BORDER_HP = 33107 # GL/glext.h:2898
GL_CONVOLUTION_BORDER_COLOR_HP = 33108 # GL/glext.h:2899
# INGR_palette_buffer (GL/glext.h:2902)
# SGIX_texture_add_env (GL/glext.h:2905)
GL_TEXTURE_ENV_BIAS_SGIX = 32958 # GL/glext.h:2906
# EXT_color_subtable (GL/glext.h:2909)
# PGI_vertex_hints (GL/glext.h:2912)
GL_VERTEX_DATA_HINT_PGI = 107050 # GL/glext.h:2913
GL_VERTEX_CONSISTENT_HINT_PGI = 107051 # GL/glext.h:2914
GL_MATERIAL_SIDE_HINT_PGI = 107052 # GL/glext.h:2915
GL_MAX_VERTEX_HINT_PGI = 107053 # GL/glext.h:2916
GL_COLOR3_BIT_PGI = 65536 # GL/glext.h:2917
GL_COLOR4_BIT_PGI = 131072 # GL/glext.h:2918
GL_EDGEFLAG_BIT_PGI = 262144 # GL/glext.h:2919
GL_INDEX_BIT_PGI = 524288 # GL/glext.h:2920
GL_MAT_AMBIENT_BIT_PGI = 1048576 # GL/glext.h:2921
GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 2097152 # GL/glext.h:2922
GL_MAT_DIFFUSE_BIT_PGI = 4194304 # GL/glext.h:2923
GL_MAT_EMISSION_BIT_PGI = 8388608 # GL/glext.h:2924
GL_MAT_COLOR_INDEXES_BIT_PGI = 16777216 # GL/glext.h:2925
GL_MAT_SHININESS_BIT_PGI = 33554432 # GL/glext.h:2926
GL_MAT_SPECULAR_BIT_PGI = 67108864 # GL/glext.h:2927
GL_NORMAL_BIT_PGI = 134217728 # GL/glext.h:2928
GL_TEXCOORD1_BIT_PGI = 268435456 # GL/glext.h:2929
GL_TEXCOORD2_BIT_PGI = 536870912 # GL/glext.h:2930
GL_TEXCOORD3_BIT_PGI = 1073741824 # GL/glext.h:2931
GL_TEXCOORD4_BIT_PGI = 2147483648 # GL/glext.h:2932
GL_VERTEX23_BIT_PGI = 4 # GL/glext.h:2933
GL_VERTEX4_BIT_PGI = 8 # GL/glext.h:2934
# PGI_misc_hints (GL/glext.h:2937)
GL_PREFER_DOUBLEBUFFER_HINT_PGI = 107000 # GL/glext.h:2938
GL_CONSERVE_MEMORY_HINT_PGI = 107005 # GL/glext.h:2939
GL_RECLAIM_MEMORY_HINT_PGI = 107006 # GL/glext.h:2940
GL_NATIVE_GRAPHICS_HANDLE_PGI = 107010 # GL/glext.h:2941
GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 107011 # GL/glext.h:2942
GL_NATIVE_GRAPHICS_END_HINT_PGI = 107012 # GL/glext.h:2943
GL_ALWAYS_FAST_HINT_PGI = 107020 # GL/glext.h:2944
GL_ALWAYS_SOFT_HINT_PGI = 107021 # GL/glext.h:2945
GL_ALLOW_DRAW_OBJ_HINT_PGI = 107022 # GL/glext.h:2946
GL_ALLOW_DRAW_WIN_HINT_PGI = 107023 # GL/glext.h:2947
GL_ALLOW_DRAW_FRG_HINT_PGI = 107024 # GL/glext.h:2948
GL_ALLOW_DRAW_MEM_HINT_PGI = 107025 # GL/glext.h:2949
GL_STRICT_DEPTHFUNC_HINT_PGI = 107030 # GL/glext.h:2950
GL_STRICT_LIGHTING_HINT_PGI = 107031 # GL/glext.h:2951
GL_STRICT_SCISSOR_HINT_PGI = 107032 # GL/glext.h:2952
GL_FULL_STIPPLE_HINT_PGI = 107033 # GL/glext.h:2953
GL_CLIP_NEAR_HINT_PGI = 107040 # GL/glext.h:2954
GL_CLIP_FAR_HINT_PGI = 107041 # GL/glext.h:2955
GL_WIDE_LINE_HINT_PGI = 107042 # GL/glext.h:2956
GL_BACK_NORMALS_HINT_PGI = 107043 # GL/glext.h:2957
# EXT_paletted_texture (GL/glext.h:2960)
GL_COLOR_INDEX1_EXT = 32994 # GL/glext.h:2961
GL_COLOR_INDEX2_EXT = 32995 # GL/glext.h:2962
GL_COLOR_INDEX4_EXT = 32996 # GL/glext.h:2963
GL_COLOR_INDEX8_EXT = 32997 # GL/glext.h:2964
GL_COLOR_INDEX12_EXT = 32998 # GL/glext.h:2965
GL_COLOR_INDEX16_EXT = 32999 # GL/glext.h:2966
GL_TEXTURE_INDEX_SIZE_EXT = 33005 # GL/glext.h:2967
# EXT_clip_volume_hint (GL/glext.h:2970)
GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 33008 # GL/glext.h:2971
# SGIX_list_priority (GL/glext.h:2974)
GL_LIST_PRIORITY_SGIX = 33154 # GL/glext.h:2975
# SGIX_ir_instrument1 (GL/glext.h:2978)
GL_IR_INSTRUMENT1_SGIX = 33151 # GL/glext.h:2979
# SGIX_calligraphic_fragment (GL/glext.h:2982)
GL_CALLIGRAPHIC_FRAGMENT_SGIX = 33155 # GL/glext.h:2983
# SGIX_texture_lod_bias (GL/glext.h:2986)
GL_TEXTURE_LOD_BIAS_S_SGIX = 33166 # GL/glext.h:2987
GL_TEXTURE_LOD_BIAS_T_SGIX = 33167 # GL/glext.h:2988
GL_TEXTURE_LOD_BIAS_R_SGIX = 33168 # GL/glext.h:2989
# SGIX_shadow_ambient (GL/glext.h:2992)
GL_SHADOW_AMBIENT_SGIX = 32959 # GL/glext.h:2993
# EXT_index_texture (GL/glext.h:2996)
# EXT_index_material (GL/glext.h:2999)
GL_INDEX_MATERIAL_EXT = 33208 # GL/glext.h:3000
GL_INDEX_MATERIAL_PARAMETER_EXT = 33209 # GL/glext.h:3001
GL_INDEX_MATERIAL_FACE_EXT = 33210 # GL/glext.h:3002
# EXT_index_func (GL/glext.h:3005)
GL_INDEX_TEST_EXT = 33205 # GL/glext.h:3006
GL_INDEX_TEST_FUNC_EXT = 33206 # GL/glext.h:3007
GL_INDEX_TEST_REF_EXT = 33207 # GL/glext.h:3008
# EXT_index_array_formats (GL/glext.h:3011)
GL_IUI_V2F_EXT = 33197 # GL/glext.h:3012
GL_IUI_V3F_EXT = 33198 # GL/glext.h:3013
GL_IUI_N3F_V2F_EXT = 33199 # GL/glext.h:3014
GL_IUI_N3F_V3F_EXT = 33200 # GL/glext.h:3015
GL_T2F_IUI_V2F_EXT = 33201 # GL/glext.h:3016
GL_T2F_IUI_V3F_EXT = 33202 # GL/glext.h:3017
GL_T2F_IUI_N3F_V2F_EXT = 33203 # GL/glext.h:3018
GL_T2F_IUI_N3F_V3F_EXT = 33204 # GL/glext.h:3019
# EXT_compiled_vertex_array (GL/glext.h:3022)
GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 33192 # GL/glext.h:3023
GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 33193 # GL/glext.h:3024
# EXT_cull_vertex (GL/glext.h:3027)
GL_CULL_VERTEX_EXT = 33194 # GL/glext.h:3028
GL_CULL_VERTEX_EYE_POSITION_EXT = 33195 # GL/glext.h:3029
GL_CULL_VERTEX_OBJECT_POSITION_EXT = 33196 # GL/glext.h:3030
# SGIX_ycrcb (GL/glext.h:3033)
GL_YCRCB_422_SGIX = 33211 # GL/glext.h:3034
GL_YCRCB_444_SGIX = 33212 # GL/glext.h:3035
# SGIX_fragment_lighting (GL/glext.h:3038)
GL_FRAGMENT_LIGHTING_SGIX = 33792 # GL/glext.h:3039
GL_FRAGMENT_COLOR_MATERIAL_SGIX = 33793 # GL/glext.h:3040
GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 33794 # GL/glext.h:3041
GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 33795 # GL/glext.h:3042
GL_MAX_FRAGMENT_LIGHTS_SGIX = 33796 # GL/glext.h:3043
GL_MAX_ACTIVE_LIGHTS_SGIX = 33797 # GL/glext.h:3044
GL_CURRENT_RASTER_NORMAL_SGIX = 33798 # GL/glext.h:3045
GL_LIGHT_ENV_MODE_SGIX = 33799 # GL/glext.h:3046
GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 33800 # GL/glext.h:3047
GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 33801 # GL/glext.h:3048
GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 33802 # GL/glext.h:3049
GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 33803 # GL/glext.h:3050
GL_FRAGMENT_LIGHT0_SGIX = 33804 # GL/glext.h:3051
GL_FRAGMENT_LIGHT1_SGIX = 33805 # GL/glext.h:3052
GL_FRAGMENT_LIGHT2_SGIX = 33806 # GL/glext.h:3053
GL_FRAGMENT_LIGHT3_SGIX = 33807 # GL/glext.h:3054
GL_FRAGMENT_LIGHT4_SGIX = 33808 # GL/glext.h:3055
GL_FRAGMENT_LIGHT5_SGIX = 33809 # GL/glext.h:3056
GL_FRAGMENT_LIGHT6_SGIX = 33810 # GL/glext.h:3057
GL_FRAGMENT_LIGHT7_SGIX = 33811 # GL/glext.h:3058
# IBM_rasterpos_clip (GL/glext.h:3061)
GL_RASTER_POSITION_UNCLIPPED_IBM = 103010 # GL/glext.h:3062
# HP_texture_lighting (GL/glext.h:3065)
GL_TEXTURE_LIGHTING_MODE_HP = 33127 # GL/glext.h:3066
GL_TEXTURE_POST_SPECULAR_HP = 33128 # GL/glext.h:3067
GL_TEXTURE_PRE_SPECULAR_HP = 33129 # GL/glext.h:3068
# EXT_draw_range_elements (GL/glext.h:3071)
GL_MAX_ELEMENTS_VERTICES_EXT = 33000 # GL/glext.h:3072
GL_MAX_ELEMENTS_INDICES_EXT = 33001 # GL/glext.h:3073
# WIN_phong_shading (GL/glext.h:3076)
GL_PHONG_WIN = 33002 # GL/glext.h:3077
GL_PHONG_HINT_WIN = 33003 # GL/glext.h:3078
# WIN_specular_fog (GL/glext.h:3081)
GL_FOG_SPECULAR_TEXTURE_WIN = 33004 # GL/glext.h:3082
# EXT_light_texture (GL/glext.h:3085)
GL_FRAGMENT_MATERIAL_EXT = 33609 # GL/glext.h:3086
GL_FRAGMENT_NORMAL_EXT = 33610 # GL/glext.h:3087
GL_FRAGMENT_COLOR_EXT = 33612 # GL/glext.h:3088
GL_ATTENUATION_EXT = 33613 # GL/glext.h:3089
GL_SHADOW_ATTENUATION_EXT = 33614 # GL/glext.h:3090
GL_TEXTURE_APPLICATION_MODE_EXT = 33615 # GL/glext.h:3091
GL_TEXTURE_LIGHT_EXT = 33616 # GL/glext.h:3092
GL_TEXTURE_MATERIAL_FACE_EXT = 33617 # GL/glext.h:3093
GL_TEXTURE_MATERIAL_PARAMETER_EXT = 33618 # GL/glext.h:3094
# SGIX_blend_alpha_minmax (GL/glext.h:3098)
GL_ALPHA_MIN_SGIX = 33568 # GL/glext.h:3099
GL_ALPHA_MAX_SGIX = 33569 # GL/glext.h:3100
# SGIX_impact_pixel_texture (GL/glext.h:3103)
GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = 33156 # GL/glext.h:3104
GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = 33157 # GL/glext.h:3105
GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = 33158 # GL/glext.h:3106
GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 33159 # GL/glext.h:3107
GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 33160 # GL/glext.h:3108
GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = 33161 # GL/glext.h:3109
GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = 33162 # GL/glext.h:3110
# EXT_bgra (GL/glext.h:3113)
GL_BGR_EXT = 32992 # GL/glext.h:3114
GL_BGRA_EXT = 32993 # GL/glext.h:3115
# SGIX_async (GL/glext.h:3118)
GL_ASYNC_MARKER_SGIX = 33577 # GL/glext.h:3119
# SGIX_async_pixel (GL/glext.h:3122)
GL_ASYNC_TEX_IMAGE_SGIX = 33628 # GL/glext.h:3123
GL_ASYNC_DRAW_PIXELS_SGIX = 33629 # GL/glext.h:3124
GL_ASYNC_READ_PIXELS_SGIX = 33630 # GL/glext.h:3125
GL_MAX_ASYNC_TEX_IMAGE_SGIX = 33631 # GL/glext.h:3126
GL_MAX_ASYNC_DRAW_PIXELS_SGIX = 33632 # GL/glext.h:3127
GL_MAX_ASYNC_READ_PIXELS_SGIX = 33633 # GL/glext.h:3128
# SGIX_async_histogram (GL/glext.h:3131)
GL_ASYNC_HISTOGRAM_SGIX = 33580 # GL/glext.h:3132
GL_MAX_ASYNC_HISTOGRAM_SGIX = 33581 # GL/glext.h:3133
# INTEL_texture_scissor (GL/glext.h:3136)
# INTEL_parallel_arrays (GL/glext.h:3139)
GL_PARALLEL_ARRAYS_INTEL = 33780 # GL/glext.h:3140
GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 33781 # GL/glext.h:3141
GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 33782 # GL/glext.h:3142
GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 33783 # GL/glext.h:3143
GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 33784 # GL/glext.h:3144
# HP_occlusion_test (GL/glext.h:3147)
GL_OCCLUSION_TEST_HP = 33125 # GL/glext.h:3148
GL_OCCLUSION_TEST_RESULT_HP = 33126 # GL/glext.h:3149
# EXT_pixel_transform (GL/glext.h:3152)
GL_PIXEL_TRANSFORM_2D_EXT = 33584 # GL/glext.h:3153
GL_PIXEL_MAG_FILTER_EXT = 33585 # GL/glext.h:3154
GL_PIXEL_MIN_FILTER_EXT = 33586 # GL/glext.h:3155
GL_PIXEL_CUBIC_WEIGHT_EXT = 33587 # GL/glext.h:3156
GL_CUBIC_EXT = 33588 # GL/glext.h:3157
GL_AVERAGE_EXT = 33589 # GL/glext.h:3158
GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 33590 # GL/glext.h:3159
GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 33591 # GL/glext.h:3160
GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = 33592 # GL/glext.h:3161
# EXT_pixel_transform_color_table (GL/glext.h:3164)
# EXT_shared_texture_palette (GL/glext.h:3167)
GL_SHARED_TEXTURE_PALETTE_EXT = 33275 # GL/glext.h:3168
# EXT_separate_specular_color (GL/glext.h:3171)
GL_LIGHT_MODEL_COLOR_CONTROL_EXT = 33272 # GL/glext.h:3172
GL_SINGLE_COLOR_EXT = 33273 # GL/glext.h:3173
GL_SEPARATE_SPECULAR_COLOR_EXT = 33274 # GL/glext.h:3174
# EXT_secondary_color (GL/glext.h:3177)
GL_COLOR_SUM_EXT = 33880 # GL/glext.h:3178
GL_CURRENT_SECONDARY_COLOR_EXT = 33881 # GL/glext.h:3179
GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 33882 # GL/glext.h:3180
GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 33883 # GL/glext.h:3181
GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 33884 # GL/glext.h:3182
GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 33885 # GL/glext.h:3183
GL_SECONDARY_COLOR_ARRAY_EXT = 33886 # GL/glext.h:3184
# EXT_texture_perturb_normal (GL/glext.h:3187)
GL_PERTURB_EXT = 34222 # GL/glext.h:3188
GL_TEXTURE_NORMAL_EXT = 34223 # GL/glext.h:3189
# EXT_multi_draw_arrays (GL/glext.h:3192)
# EXT_fog_coord (GL/glext.h:3195)
GL_FOG_COORDINATE_SOURCE_EXT = 33872 # GL/glext.h:3196
GL_FOG_COORDINATE_EXT = 33873 # GL/glext.h:3197
GL_FRAGMENT_DEPTH_EXT = 33874 # GL/glext.h:3198
GL_CURRENT_FOG_COORDINATE_EXT = 33875 # GL/glext.h:3199
GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 33876 # GL/glext.h:3200
GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 33877 # GL/glext.h:3201
GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 33878 # GL/glext.h:3202
GL_FOG_COORDINATE_ARRAY_EXT = 33879 # GL/glext.h:3203
# REND_screen_coordinates (GL/glext.h:3206)
GL_SCREEN_COORDINATES_REND = 33936 # GL/glext.h:3207
GL_INVERTED_SCREEN_W_REND = 33937 # GL/glext.h:3208
# EXT_coordinate_frame (GL/glext.h:3211)
GL_TANGENT_ARRAY_EXT = 33849 # GL/glext.h:3212
GL_BINORMAL_ARRAY_EXT = 33850 # GL/glext.h:3213
GL_CURRENT_TANGENT_EXT = 33851 # GL/glext.h:3214
GL_CURRENT_BINORMAL_EXT = 33852 # GL/glext.h:3215
GL_TANGENT_ARRAY_TYPE_EXT = 33854 # GL/glext.h:3216
GL_TANGENT_ARRAY_STRIDE_EXT = 33855 # GL/glext.h:3217
GL_BINORMAL_ARRAY_TYPE_EXT = 33856 # GL/glext.h:3218
GL_BINORMAL_ARRAY_STRIDE_EXT = 33857 # GL/glext.h:3219
GL_TANGENT_ARRAY_POINTER_EXT = 33858 # GL/glext.h:3220
GL_BINORMAL_ARRAY_POINTER_EXT = 33859 # GL/glext.h:3221
GL_MAP1_TANGENT_EXT = 33860 # GL/glext.h:3222
GL_MAP2_TANGENT_EXT = 33861 # GL/glext.h:3223
GL_MAP1_BINORMAL_EXT = 33862 # GL/glext.h:3224
GL_MAP2_BINORMAL_EXT = 33863 # GL/glext.h:3225
# EXT_texture_env_combine (GL/glext.h:3228)
GL_COMBINE_EXT = 34160 # GL/glext.h:3229
GL_COMBINE_RGB_EXT = 34161 # GL/glext.h:3230
GL_COMBINE_ALPHA_EXT = 34162 # GL/glext.h:3231
GL_RGB_SCALE_EXT = 34163 # GL/glext.h:3232
GL_ADD_SIGNED_EXT = 34164 # GL/glext.h:3233
GL_INTERPOLATE_EXT = 34165 # GL/glext.h:3234
GL_CONSTANT_EXT = 34166 # GL/glext.h:3235
GL_PRIMARY_COLOR_EXT = 34167 # GL/glext.h:3236
GL_PREVIOUS_EXT = 34168 # GL/glext.h:3237
GL_SOURCE0_RGB_EXT = 34176 # GL/glext.h:3238
GL_SOURCE1_RGB_EXT = 34177 # GL/glext.h:3239
GL_SOURCE2_RGB_EXT = 34178 # GL/glext.h:3240
GL_SOURCE0_ALPHA_EXT = 34184 # GL/glext.h:3241
GL_SOURCE1_ALPHA_EXT = 34185 # GL/glext.h:3242
GL_SOURCE2_ALPHA_EXT = 34186 # GL/glext.h:3243
GL_OPERAND0_RGB_EXT = 34192 # GL/glext.h:3244
GL_OPERAND1_RGB_EXT = 34193 # GL/glext.h:3245
GL_OPERAND2_RGB_EXT = 34194 # GL/glext.h:3246
GL_OPERAND0_ALPHA_EXT = 34200 # GL/glext.h:3247
GL_OPERAND1_ALPHA_EXT = 34201 # GL/glext.h:3248
GL_OPERAND2_ALPHA_EXT = 34202 # GL/glext.h:3249
# APPLE_specular_vector (GL/glext.h:3252)
GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 34224 # GL/glext.h:3253
# APPLE_transform_hint (GL/glext.h:3256)
GL_TRANSFORM_HINT_APPLE = 34225 # GL/glext.h:3257
# SGIX_fog_scale (GL/glext.h:3260)
GL_FOG_SCALE_SGIX = 33276 # GL/glext.h:3261
GL_FOG_SCALE_VALUE_SGIX = 33277 # GL/glext.h:3262
# SUNX_constant_data (GL/glext.h:3265)
GL_UNPACK_CONSTANT_DATA_SUNX = 33237 # GL/glext.h:3266
GL_TEXTURE_CONSTANT_DATA_SUNX = 33238 # GL/glext.h:3267
# SUN_global_alpha (GL/glext.h:3270)
GL_GLOBAL_ALPHA_SUN = 33241 # GL/glext.h:3271
GL_GLOBAL_ALPHA_FACTOR_SUN = 33242 # GL/glext.h:3272
# SUN_triangle_list (GL/glext.h:3275)
GL_RESTART_SUN = 1 # GL/glext.h:3276
GL_REPLACE_MIDDLE_SUN = 2 # GL/glext.h:3277
GL_REPLACE_OLDEST_SUN = 3 # GL/glext.h:3278
GL_TRIANGLE_LIST_SUN = 33239 # GL/glext.h:3279
GL_REPLACEMENT_CODE_SUN = 33240 # GL/glext.h:3280
GL_REPLACEMENT_CODE_ARRAY_SUN = 34240 # GL/glext.h:3281
GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 34241 # GL/glext.h:3282
GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 34242 # GL/glext.h:3283
GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 34243 # GL/glext.h:3284
GL_R1UI_V3F_SUN = 34244 # GL/glext.h:3285
GL_R1UI_C4UB_V3F_SUN = 34245 # GL/glext.h:3286
GL_R1UI_C3F_V3F_SUN = 34246 # GL/glext.h:3287
GL_R1UI_N3F_V3F_SUN = 34247 # GL/glext.h:3288
GL_R1UI_C4F_N3F_V3F_SUN = 34248 # GL/glext.h:3289
GL_R1UI_T2F_V3F_SUN = 34249 # GL/glext.h:3290
GL_R1UI_T2F_N3F_V3F_SUN = 34250 # GL/glext.h:3291
GL_R1UI_T2F_C4F_N3F_V3F_SUN = 34251 # GL/glext.h:3292
# SUN_vertex (GL/glext.h:3295)
# EXT_blend_func_separate (GL/glext.h:3298)
GL_BLEND_DST_RGB_EXT = 32968 # GL/glext.h:3299
GL_BLEND_SRC_RGB_EXT = 32969 # GL/glext.h:3300
GL_BLEND_DST_ALPHA_EXT = 32970 # GL/glext.h:3301
GL_BLEND_SRC_ALPHA_EXT = 32971 # GL/glext.h:3302
# INGR_color_clamp (GL/glext.h:3305)
GL_RED_MIN_CLAMP_INGR = 34144 # GL/glext.h:3306
GL_GREEN_MIN_CLAMP_INGR = 34145 # GL/glext.h:3307
GL_BLUE_MIN_CLAMP_INGR = 34146 # GL/glext.h:3308
GL_ALPHA_MIN_CLAMP_INGR = 34147 # GL/glext.h:3309
GL_RED_MAX_CLAMP_INGR = 34148 # GL/glext.h:3310
GL_GREEN_MAX_CLAMP_INGR = 34149 # GL/glext.h:3311
GL_BLUE_MAX_CLAMP_INGR = 34150 # GL/glext.h:3312
GL_ALPHA_MAX_CLAMP_INGR = 34151 # GL/glext.h:3313
# INGR_interlace_read (GL/glext.h:3316)
GL_INTERLACE_READ_INGR = 34152 # GL/glext.h:3317
# EXT_stencil_wrap (GL/glext.h:3320)
GL_INCR_WRAP_EXT = 34055 # GL/glext.h:3321
GL_DECR_WRAP_EXT = 34056 # GL/glext.h:3322
# EXT_422_pixels (GL/glext.h:3325)
GL_422_EXT = 32972 # GL/glext.h:3326
GL_422_REV_EXT = 32973 # GL/glext.h:3327
GL_422_AVERAGE_EXT = 32974 # GL/glext.h:3328
GL_422_REV_AVERAGE_EXT = 32975 # GL/glext.h:3329
# NV_texgen_reflection (GL/glext.h:3332)
GL_NORMAL_MAP_NV = 34065 # GL/glext.h:3333
GL_REFLECTION_MAP_NV = 34066 # GL/glext.h:3334
# EXT_texture_cube_map (GL/glext.h:3337)
GL_NORMAL_MAP_EXT = 34065 # GL/glext.h:3338
GL_REFLECTION_MAP_EXT = 34066 # GL/glext.h:3339
GL_TEXTURE_CUBE_MAP_EXT = 34067 # GL/glext.h:3340
GL_TEXTURE_BINDING_CUBE_MAP_EXT = 34068 # GL/glext.h:3341
GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 34069 # GL/glext.h:3342
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 34070 # GL/glext.h:3343
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 34071 # GL/glext.h:3344
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 34072 # GL/glext.h:3345
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 34073 # GL/glext.h:3346
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 34074 # GL/glext.h:3347
GL_PROXY_TEXTURE_CUBE_MAP_EXT = 34075 # GL/glext.h:3348
GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 34076 # GL/glext.h:3349
# SUN_convolution_border_modes (GL/glext.h:3352)
GL_WRAP_BORDER_SUN = 33236 # GL/glext.h:3353
# EXT_texture_env_add (GL/glext.h:3356)
# EXT_texture_lod_bias (GL/glext.h:3359)
GL_MAX_TEXTURE_LOD_BIAS_EXT = 34045 # GL/glext.h:3360
GL_TEXTURE_FILTER_CONTROL_EXT = 34048 # GL/glext.h:3361
GL_TEXTURE_LOD_BIAS_EXT = 34049 # GL/glext.h:3362
# EXT_texture_filter_anisotropic (GL/glext.h:3365)
GL_TEXTURE_MAX_ANISOTROPY_EXT = 34046 # GL/glext.h:3366
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047 # GL/glext.h:3367
# EXT_vertex_weighting (GL/glext.h:3370)
GL_MODELVIEW0_STACK_DEPTH_EXT = 2979 # GL/glext.h:3371
GL_MODELVIEW1_STACK_DEPTH_EXT = 34050 # GL/glext.h:3372
GL_MODELVIEW0_MATRIX_EXT = 2982 # GL/glext.h:3373
GL_MODELVIEW1_MATRIX_EXT = 34054 # GL/glext.h:3374
GL_VERTEX_WEIGHTING_EXT = 34057 # GL/glext.h:3375
GL_MODELVIEW0_EXT = 5888 # GL/glext.h:3376
GL_MODELVIEW1_EXT = 34058 # GL/glext.h:3377
GL_CURRENT_VERTEX_WEIGHT_EXT = 34059 # GL/glext.h:3378
GL_VERTEX_WEIGHT_ARRAY_EXT = 34060 # GL/glext.h:3379
GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 34061 # GL/glext.h:3380
GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 34062 # GL/glext.h:3381
GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 34063 # GL/glext.h:3382
GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 34064 # GL/glext.h:3383
# NV_light_max_exponent (GL/glext.h:3386)
GL_MAX_SHININESS_NV = 34052 # GL/glext.h:3387
GL_MAX_SPOT_EXPONENT_NV = 34053 # GL/glext.h:3388
# NV_vertex_array_range (GL/glext.h:3391)
GL_VERTEX_ARRAY_RANGE_NV = 34077 # GL/glext.h:3392
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 34078 # GL/glext.h:3393
GL_VERTEX_ARRAY_RANGE_VALID_NV = 34079 # GL/glext.h:3394
GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 34080 # GL/glext.h:3395
GL_VERTEX_ARRAY_RANGE_POINTER_NV = 34081 # GL/glext.h:3396
# NV_register_combiners (GL/glext.h:3399)
GL_REGISTER_COMBINERS_NV = 34082 # GL/glext.h:3400
GL_VARIABLE_A_NV = 34083 # GL/glext.h:3401
GL_VARIABLE_B_NV = 34084 # GL/glext.h:3402
GL_VARIABLE_C_NV = 34085 # GL/glext.h:3403
GL_VARIABLE_D_NV = 34086 # GL/glext.h:3404
GL_VARIABLE_E_NV = 34087 # GL/glext.h:3405
GL_VARIABLE_F_NV = 34088 # GL/glext.h:3406
GL_VARIABLE_G_NV = 34089 # GL/glext.h:3407
GL_CONSTANT_COLOR0_NV = 34090 # GL/glext.h:3408
GL_CONSTANT_COLOR1_NV = 34091 # GL/glext.h:3409
GL_PRIMARY_COLOR_NV = 34092 # GL/glext.h:3410
GL_SECONDARY_COLOR_NV = 34093 # GL/glext.h:3411
GL_SPARE0_NV = 34094 # GL/glext.h:3412
GL_SPARE1_NV = 34095 # GL/glext.h:3413
GL_DISCARD_NV = 34096 # GL/glext.h:3414
GL_E_TIMES_F_NV = 34097 # GL/glext.h:3415
GL_SPARE0_PLUS_SECONDARY_COLOR_NV = 34098 # GL/glext.h:3416
GL_UNSIGNED_IDENTITY_NV = 34102 # GL/glext.h:3417
GL_UNSIGNED_INVERT_NV = 34103 # GL/glext.h:3418
GL_EXPAND_NORMAL_NV = 34104 # GL/glext.h:3419
GL_EXPAND_NEGATE_NV = 34105 # GL/glext.h:3420
GL_HALF_BIAS_NORMAL_NV = 34106 # GL/glext.h:3421
GL_HALF_BIAS_NEGATE_NV = 34107 # GL/glext.h:3422
GL_SIGNED_IDENTITY_NV = 34108 # GL/glext.h:3423
GL_SIGNED_NEGATE_NV = 34109 # GL/glext.h:3424
GL_SCALE_BY_TWO_NV = 34110 # GL/glext.h:3425
GL_SCALE_BY_FOUR_NV = 34111 # GL/glext.h:3426
GL_SCALE_BY_ONE_HALF_NV = 34112 # GL/glext.h:3427
GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 34113 # GL/glext.h:3428
GL_COMBINER_INPUT_NV = 34114 # GL/glext.h:3429
GL_COMBINER_MAPPING_NV = 34115 # GL/glext.h:3430
GL_COMBINER_COMPONENT_USAGE_NV = 34116 # GL/glext.h:3431
GL_COMBINER_AB_DOT_PRODUCT_NV = 34117 # GL/glext.h:3432
GL_COMBINER_CD_DOT_PRODUCT_NV = 34118 # GL/glext.h:3433
GL_COMBINER_MUX_SUM_NV = 34119 # GL/glext.h:3434
GL_COMBINER_SCALE_NV = 34120 # GL/glext.h:3435
GL_COMBINER_BIAS_NV = 34121 # GL/glext.h:3436
GL_COMBINER_AB_OUTPUT_NV = 34122 # GL/glext.h:3437
GL_COMBINER_CD_OUTPUT_NV = 34123 # GL/glext.h:3438
GL_COMBINER_SUM_OUTPUT_NV = 34124 # GL/glext.h:3439
GL_MAX_GENERAL_COMBINERS_NV = 34125 # GL/glext.h:3440
GL_NUM_GENERAL_COMBINERS_NV = 34126 # GL/glext.h:3441
GL_COLOR_SUM_CLAMP_NV = 34127 # GL/glext.h:3442
GL_COMBINER0_NV = 34128 # GL/glext.h:3443
GL_COMBINER1_NV = 34129 # GL/glext.h:3444
GL_COMBINER2_NV = 34130 # GL/glext.h:3445
GL_COMBINER3_NV = 34131 # GL/glext.h:3446
GL_COMBINER4_NV = 34132 # GL/glext.h:3447
GL_COMBINER5_NV = 34133 # GL/glext.h:3448
GL_COMBINER6_NV = 34134 # GL/glext.h:3449
GL_COMBINER7_NV = 34135 # GL/glext.h:3450
# NV_fog_distance (GL/glext.h:3458)
GL_FOG_DISTANCE_MODE_NV = 34138 # GL/glext.h:3459
GL_EYE_RADIAL_NV = 34139 # GL/glext.h:3460
GL_EYE_PLANE_ABSOLUTE_NV = 34140 # GL/glext.h:3461
# NV_texgen_emboss (GL/glext.h:3465)
GL_EMBOSS_LIGHT_NV = 34141 # GL/glext.h:3466
GL_EMBOSS_CONSTANT_NV = 34142 # GL/glext.h:3467
GL_EMBOSS_MAP_NV = 34143 # GL/glext.h:3468
# NV_blend_square (GL/glext.h:3471)
# NV_texture_env_combine4 (GL/glext.h:3474)
GL_COMBINE4_NV = 34051 # GL/glext.h:3475
GL_SOURCE3_RGB_NV = 34179 # GL/glext.h:3476
GL_SOURCE3_ALPHA_NV = 34187 # GL/glext.h:3477
GL_OPERAND3_RGB_NV = 34195 # GL/glext.h:3478
GL_OPERAND3_ALPHA_NV = 34203 # GL/glext.h:3479
# MESA_resize_buffers (GL/glext.h:3482)
# MESA_window_pos (GL/glext.h:3485)
# EXT_texture_compression_s3tc (GL/glext.h:3488)
GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776 # GL/glext.h:3489
GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777 # GL/glext.h:3490
GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778 # GL/glext.h:3491
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779 # GL/glext.h:3492
# IBM_cull_vertex (GL/glext.h:3495)
GL_CULL_VERTEX_IBM = 103050 # GL/glext.h:3496
# IBM_multimode_draw_arrays (GL/glext.h:3499)
# IBM_vertex_array_lists (GL/glext.h:3502)
GL_VERTEX_ARRAY_LIST_IBM = 103070 # GL/glext.h:3503
GL_NORMAL_ARRAY_LIST_IBM = 103071 # GL/glext.h:3504
GL_COLOR_ARRAY_LIST_IBM = 103072 # GL/glext.h:3505
GL_INDEX_ARRAY_LIST_IBM = 103073 # GL/glext.h:3506
GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074 # GL/glext.h:3507
GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075 # GL/glext.h:3508
GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076 # GL/glext.h:3509
GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077 # GL/glext.h:3510
GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080 # GL/glext.h:3511
GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081 # GL/glext.h:3512
GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082 # GL/glext.h:3513
GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083 # GL/glext.h:3514
GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084 # GL/glext.h:3515
GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085 # GL/glext.h:3516
GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086 # GL/glext.h:3517
GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087 # GL/glext.h:3518
# SGIX_subsample (GL/glext.h:3521)
GL_PACK_SUBSAMPLE_RATE_SGIX = 34208 # GL/glext.h:3522
GL_UNPACK_SUBSAMPLE_RATE_SGIX = 34209 # GL/glext.h:3523
GL_PIXEL_SUBSAMPLE_4444_SGIX = 34210 # GL/glext.h:3524
GL_PIXEL_SUBSAMPLE_2424_SGIX = 34211 # GL/glext.h:3525
GL_PIXEL_SUBSAMPLE_4242_SGIX = 34212 # GL/glext.h:3526
# SGIX_ycrcb_subsample (GL/glext.h:3529)
# SGIX_ycrcba (GL/glext.h:3532)
GL_YCRCB_SGIX = 33560 # GL/glext.h:3533
GL_YCRCBA_SGIX = 33561 # GL/glext.h:3534
# SGI_depth_pass_instrument (GL/glext.h:3537)
GL_DEPTH_PASS_INSTRUMENT_SGIX = 33552 # GL/glext.h:3538
GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 33553 # GL/glext.h:3539
GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = 33554 # GL/glext.h:3540
# 3DFX_texture_compression_FXT1 (GL/glext.h:3543)
GL_COMPRESSED_RGB_FXT1_3DFX = 34480 # GL/glext.h:3544
GL_COMPRESSED_RGBA_FXT1_3DFX = 34481 # GL/glext.h:3545
# 3DFX_multisample (GL/glext.h:3548)
GL_MULTISAMPLE_3DFX = 34482 # GL/glext.h:3549
GL_SAMPLE_BUFFERS_3DFX = 34483 # GL/glext.h:3550
GL_SAMPLES_3DFX = 34484 # GL/glext.h:3551
GL_MULTISAMPLE_BIT_3DFX = 536870912 # GL/glext.h:3552
# 3DFX_tbuffer (GL/glext.h:3555)
# EXT_multisample (GL/glext.h:3558)
GL_MULTISAMPLE_EXT = 32925 # GL/glext.h:3559
GL_SAMPLE_ALPHA_TO_MASK_EXT = 32926 # GL/glext.h:3560
GL_SAMPLE_ALPHA_TO_ONE_EXT = 32927 # GL/glext.h:3561
GL_SAMPLE_MASK_EXT = 32928 # GL/glext.h:3562
GL_1PASS_EXT = 32929 # GL/glext.h:3563
GL_2PASS_0_EXT = 32930 # GL/glext.h:3564
GL_2PASS_1_EXT = 32931 # GL/glext.h:3565
GL_4PASS_0_EXT = 32932 # GL/glext.h:3566
GL_4PASS_1_EXT = 32933 # GL/glext.h:3567
GL_4PASS_2_EXT = 32934 # GL/glext.h:3568
GL_4PASS_3_EXT = 32935 # GL/glext.h:3569
GL_SAMPLE_BUFFERS_EXT = 32936 # GL/glext.h:3570
GL_SAMPLES_EXT = 32937 # GL/glext.h:3571
GL_SAMPLE_MASK_VALUE_EXT = 32938 # GL/glext.h:3572
GL_SAMPLE_MASK_INVERT_EXT = 32939 # GL/glext.h:3573
GL_SAMPLE_PATTERN_EXT = 32940 # GL/glext.h:3574
GL_MULTISAMPLE_BIT_EXT = 536870912 # GL/glext.h:3575
# SGIX_vertex_preclip (GL/glext.h:3578)
GL_VERTEX_PRECLIP_SGIX = 33774 # GL/glext.h:3579
GL_VERTEX_PRECLIP_HINT_SGIX = 33775 # GL/glext.h:3580
# SGIX_convolution_accuracy (GL/glext.h:3583)
GL_CONVOLUTION_HINT_SGIX = 33558 # GL/glext.h:3584
# SGIX_resample (GL/glext.h:3587)
GL_PACK_RESAMPLE_SGIX = 33836 # GL/glext.h:3588
GL_UNPACK_RESAMPLE_SGIX = 33837 # GL/glext.h:3589
GL_RESAMPLE_REPLICATE_SGIX = 33838 # GL/glext.h:3590
GL_RESAMPLE_ZERO_FILL_SGIX = 33839 # GL/glext.h:3591
GL_RESAMPLE_DECIMATE_SGIX = 33840 # GL/glext.h:3592
# SGIS_point_line_texgen (GL/glext.h:3595)
GL_EYE_DISTANCE_TO_POINT_SGIS = 33264 # GL/glext.h:3596
GL_OBJECT_DISTANCE_TO_POINT_SGIS = 33265 # GL/glext.h:3597
GL_EYE_DISTANCE_TO_LINE_SGIS = 33266 # GL/glext.h:3598
GL_OBJECT_DISTANCE_TO_LINE_SGIS = 33267 # GL/glext.h:3599
GL_EYE_POINT_SGIS = 33268 # GL/glext.h:3600
GL_OBJECT_POINT_SGIS = 33269 # GL/glext.h:3601
GL_EYE_LINE_SGIS = 33270 # GL/glext.h:3602
GL_OBJECT_LINE_SGIS = 33271 # GL/glext.h:3603
# SGIS_texture_color_mask (GL/glext.h:3606)
GL_TEXTURE_COLOR_WRITEMASK_SGIS = 33263 # GL/glext.h:3607
# EXT_texture_env_dot3 (GL/glext.h:3610)
GL_DOT3_RGB_EXT = 34624 # GL/glext.h:3611
GL_DOT3_RGBA_EXT = 34625 # GL/glext.h:3612
# ATI_texture_mirror_once (GL/glext.h:3615)
GL_MIRROR_CLAMP_ATI = 34626 # GL/glext.h:3616
GL_MIRROR_CLAMP_TO_EDGE_ATI = 34627 # GL/glext.h:3617
# NV_fence (GL/glext.h:3620)
GL_ALL_COMPLETED_NV = 34034 # GL/glext.h:3621
GL_FENCE_STATUS_NV = 34035 # GL/glext.h:3622
GL_FENCE_CONDITION_NV = 34036 # GL/glext.h:3623
# IBM_texture_mirrored_repeat (GL/glext.h:3626)
GL_MIRRORED_REPEAT_IBM = 33648 # GL/glext.h:3627
# NV_evaluators (GL/glext.h:3630)
GL_EVAL_2D_NV = 34496 # GL/glext.h:3631
GL_EVAL_TRIANGULAR_2D_NV = 34497 # GL/glext.h:3632
GL_MAP_TESSELLATION_NV = 34498 # GL/glext.h:3633
GL_MAP_ATTRIB_U_ORDER_NV = 34499 # GL/glext.h:3634
GL_MAP_ATTRIB_V_ORDER_NV = 34500 # GL/glext.h:3635
GL_EVAL_FRACTIONAL_TESSELLATION_NV = 34501 # GL/glext.h:3636
GL_EVAL_VERTEX_ATTRIB0_NV = 34502 # GL/glext.h:3637
GL_EVAL_VERTEX_ATTRIB1_NV = 34503 # GL/glext.h:3638
GL_EVAL_VERTEX_ATTRIB2_NV = 34504 # GL/glext.h:3639
GL_EVAL_VERTEX_ATTRIB3_NV = 34505 # GL/glext.h:3640
GL_EVAL_VERTEX_ATTRIB4_NV = 34506 # GL/glext.h:3641
GL_EVAL_VERTEX_ATTRIB5_NV = 34507 # GL/glext.h:3642
GL_EVAL_VERTEX_ATTRIB6_NV = 34508 # GL/glext.h:3643
GL_EVAL_VERTEX_ATTRIB7_NV = 34509 # GL/glext.h:3644
GL_EVAL_VERTEX_ATTRIB8_NV = 34510 # GL/glext.h:3645
GL_EVAL_VERTEX_ATTRIB9_NV = 34511 # GL/glext.h:3646
GL_EVAL_VERTEX_ATTRIB10_NV = 34512 # GL/glext.h:3647
GL_EVAL_VERTEX_ATTRIB11_NV = 34513 # GL/glext.h:3648
GL_EVAL_VERTEX_ATTRIB12_NV = 34514 # GL/glext.h:3649
GL_EVAL_VERTEX_ATTRIB13_NV = 34515 # GL/glext.h:3650
GL_EVAL_VERTEX_ATTRIB14_NV = 34516 # GL/glext.h:3651
GL_EVAL_VERTEX_ATTRIB15_NV = 34517 # GL/glext.h:3652
GL_MAX_MAP_TESSELLATION_NV = 34518 # GL/glext.h:3653
GL_MAX_RATIONAL_EVAL_ORDER_NV = 34519 # GL/glext.h:3654
# NV_packed_depth_stencil (GL/glext.h:3657)
GL_DEPTH_STENCIL_NV = 34041 # GL/glext.h:3658
GL_UNSIGNED_INT_24_8_NV = 34042 # GL/glext.h:3659
# NV_register_combiners2 (GL/glext.h:3662)
GL_PER_STAGE_CONSTANTS_NV = 34101 # GL/glext.h:3663
# NV_texture_compression_vtc (GL/glext.h:3666)
# NV_texture_rectangle (GL/glext.h:3669)
GL_TEXTURE_RECTANGLE_NV = 34037 # GL/glext.h:3670
GL_TEXTURE_BINDING_RECTANGLE_NV = 34038 # GL/glext.h:3671
GL_PROXY_TEXTURE_RECTANGLE_NV = 34039 # GL/glext.h:3672
GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = 34040 # GL/glext.h:3673
# NV_texture_shader (GL/glext.h:3676)
GL_OFFSET_TEXTURE_RECTANGLE_NV = 34380 # GL/glext.h:3677
GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 34381 # GL/glext.h:3678
GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 34382 # GL/glext.h:3679
GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 34521 # GL/glext.h:3680
GL_UNSIGNED_INT_S8_S8_8_8_NV = 34522 # GL/glext.h:3681
GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = 34523 # GL/glext.h:3682
GL_DSDT_MAG_INTENSITY_NV = 34524 # GL/glext.h:3683
GL_SHADER_CONSISTENT_NV = 34525 # GL/glext.h:3684
GL_TEXTURE_SHADER_NV = 34526 # GL/glext.h:3685
GL_SHADER_OPERATION_NV = 34527 # GL/glext.h:3686
GL_CULL_MODES_NV = 34528 # GL/glext.h:3687
GL_OFFSET_TEXTURE_MATRIX_NV = 34529 # GL/glext.h:3688
GL_OFFSET_TEXTURE_SCALE_NV = 34530 # GL/glext.h:3689
GL_OFFSET_TEXTURE_BIAS_NV = 34531 # GL/glext.h:3690
GL_OFFSET_TEXTURE_2D_MATRIX_NV = 34529 # GL/glext.h:3691
GL_OFFSET_TEXTURE_2D_SCALE_NV = 34530 # GL/glext.h:3692
GL_OFFSET_TEXTURE_2D_BIAS_NV = 34531 # GL/glext.h:3693
GL_PREVIOUS_TEXTURE_INPUT_NV = 34532 # GL/glext.h:3694
GL_CONST_EYE_NV = 34533 # GL/glext.h:3695
GL_PASS_THROUGH_NV = 34534 # GL/glext.h:3696
GL_CULL_FRAGMENT_NV = 34535 # GL/glext.h:3697
GL_OFFSET_TEXTURE_2D_NV = 34536 # GL/glext.h:3698
GL_DEPENDENT_AR_TEXTURE_2D_NV = 34537 # GL/glext.h:3699
GL_DEPENDENT_GB_TEXTURE_2D_NV = 34538 # GL/glext.h:3700
GL_DOT_PRODUCT_NV = 34540 # GL/glext.h:3701
GL_DOT_PRODUCT_DEPTH_REPLACE_NV = 34541 # GL/glext.h:3702
GL_DOT_PRODUCT_TEXTURE_2D_NV = 34542 # GL/glext.h:3703
GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 34544 # GL/glext.h:3704
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 34545 # GL/glext.h:3705
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 34546 # GL/glext.h:3706
GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 34547 # GL/glext.h:3707
GL_HILO_NV = 34548 # GL/glext.h:3708
GL_DSDT_NV = 34549 # GL/glext.h:3709
GL_DSDT_MAG_NV = 34550 # GL/glext.h:3710
GL_DSDT_MAG_VIB_NV = 34551 # GL/glext.h:3711
GL_HILO16_NV = 34552 # GL/glext.h:3712
GL_SIGNED_HILO_NV = 34553 # GL/glext.h:3713
GL_SIGNED_HILO16_NV = 34554 # GL/glext.h:3714
GL_SIGNED_RGBA_NV = 34555 # GL/glext.h:3715
GL_SIGNED_RGBA8_NV = 34556 # GL/glext.h:3716
GL_SIGNED_RGB_NV = 34558 # GL/glext.h:3717
GL_SIGNED_RGB8_NV = 34559 # GL/glext.h:3718
GL_SIGNED_LUMINANCE_NV = 34561 # GL/glext.h:3719
GL_SIGNED_LUMINANCE8_NV = 34562 # GL/glext.h:3720
GL_SIGNED_LUMINANCE_ALPHA_NV = 34563 # GL/glext.h:3721
GL_SIGNED_LUMINANCE8_ALPHA8_NV = 34564 # GL/glext.h:3722
GL_SIGNED_ALPHA_NV = 34565 # GL/glext.h:3723
GL_SIGNED_ALPHA8_NV = 34566 # GL/glext.h:3724
GL_SIGNED_INTENSITY_NV = 34567 # GL/glext.h:3725
GL_SIGNED_INTENSITY8_NV = 34568 # GL/glext.h:3726
GL_DSDT8_NV = 34569 # GL/glext.h:3727
GL_DSDT8_MAG8_NV = 34570 # GL/glext.h:3728
GL_DSDT8_MAG8_INTENSITY8_NV = 34571 # GL/glext.h:3729
GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 34572 # GL/glext.h:3730
GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 34573 # GL/glext.h:3731
GL_HI_SCALE_NV = 34574 # GL/glext.h:3732
GL_LO_SCALE_NV = 34575 # GL/glext.h:3733
GL_DS_SCALE_NV = 34576 # GL/glext.h:3734
GL_DT_SCALE_NV = 34577 # GL/glext.h:3735
GL_MAGNITUDE_SCALE_NV = 34578 # GL/glext.h:3736
GL_VIBRANCE_SCALE_NV = 34579 # GL/glext.h:3737
GL_HI_BIAS_NV = 34580 # GL/glext.h:3738
GL_LO_BIAS_NV = 34581 # GL/glext.h:3739
GL_DS_BIAS_NV = 34582 # GL/glext.h:3740
GL_DT_BIAS_NV = 34583 # GL/glext.h:3741
GL_MAGNITUDE_BIAS_NV = 34584 # GL/glext.h:3742
GL_VIBRANCE_BIAS_NV = 34585 # GL/glext.h:3743
GL_TEXTURE_BORDER_VALUES_NV = 34586 # GL/glext.h:3744
GL_TEXTURE_HI_SIZE_NV = 34587 # GL/glext.h:3745
GL_TEXTURE_LO_SIZE_NV = 34588 # GL/glext.h:3746
GL_TEXTURE_DS_SIZE_NV = 34589 # GL/glext.h:3747
GL_TEXTURE_DT_SIZE_NV = 34590 # GL/glext.h:3748
GL_TEXTURE_MAG_SIZE_NV = 34591 # GL/glext.h:3749
# NV_texture_shader2 (GL/glext.h:3752)
GL_DOT_PRODUCT_TEXTURE_3D_NV = 34543 # GL/glext.h:3753
# NV_vertex_array_range2 (GL/glext.h:3756)
GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 34099 # GL/glext.h:3757
# NV_vertex_program (GL/glext.h:3760)
GL_VERTEX_PROGRAM_NV = 34336 # GL/glext.h:3761
GL_VERTEX_STATE_PROGRAM_NV = 34337 # GL/glext.h:3762
GL_ATTRIB_ARRAY_SIZE_NV = 34339 # GL/glext.h:3763
GL_ATTRIB_ARRAY_STRIDE_NV = 34340 # GL/glext.h:3764
GL_ATTRIB_ARRAY_TYPE_NV = 34341 # GL/glext.h:3765
GL_CURRENT_ATTRIB_NV = 34342 # GL/glext.h:3766
GL_PROGRAM_LENGTH_NV = 34343 # GL/glext.h:3767
GL_PROGRAM_STRING_NV = 34344 # GL/glext.h:3768
GL_MODELVIEW_PROJECTION_NV = 34345 # GL/glext.h:3769
GL_IDENTITY_NV = 34346 # GL/glext.h:3770
GL_INVERSE_NV = 34347 # GL/glext.h:3771
GL_TRANSPOSE_NV = 34348 # GL/glext.h:3772
GL_INVERSE_TRANSPOSE_NV = 34349 # GL/glext.h:3773
GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 34350 # GL/glext.h:3774
GL_MAX_TRACK_MATRICES_NV = 34351 # GL/glext.h:3775
GL_MATRIX0_NV = 34352 # GL/glext.h:3776
GL_MATRIX1_NV = 34353 # GL/glext.h:3777
GL_MATRIX2_NV = 34354 # GL/glext.h:3778
GL_MATRIX3_NV = 34355 # GL/glext.h:3779
GL_MATRIX4_NV = 34356 # GL/glext.h:3780
GL_MATRIX5_NV = 34357 # GL/glext.h:3781
GL_MATRIX6_NV = 34358 # GL/glext.h:3782
GL_MATRIX7_NV = 34359 # GL/glext.h:3783
GL_CURRENT_MATRIX_STACK_DEPTH_NV = 34368 # GL/glext.h:3784
GL_CURRENT_MATRIX_NV = 34369 # GL/glext.h:3785
GL_VERTEX_PROGRAM_POINT_SIZE_NV = 34370 # GL/glext.h:3786
GL_VERTEX_PROGRAM_TWO_SIDE_NV = 34371 # GL/glext.h:3787
GL_PROGRAM_PARAMETER_NV = 34372 # GL/glext.h:3788
GL_ATTRIB_ARRAY_POINTER_NV = 34373 # GL/glext.h:3789
GL_PROGRAM_TARGET_NV = 34374 # GL/glext.h:3790
GL_PROGRAM_RESIDENT_NV = 34375 # GL/glext.h:3791
GL_TRACK_MATRIX_NV = 34376 # GL/glext.h:3792
GL_TRACK_MATRIX_TRANSFORM_NV = 34377 # GL/glext.h:3793
GL_VERTEX_PROGRAM_BINDING_NV = 34378 # GL/glext.h:3794
GL_PROGRAM_ERROR_POSITION_NV = 34379 # GL/glext.h:3795
GL_VERTEX_ATTRIB_ARRAY0_NV = 34384 # GL/glext.h:3796
GL_VERTEX_ATTRIB_ARRAY1_NV = 34385 # GL/glext.h:3797
GL_VERTEX_ATTRIB_ARRAY2_NV = 34386 # GL/glext.h:3798
GL_VERTEX_ATTRIB_ARRAY3_NV = 34387 # GL/glext.h:3799
GL_VERTEX_ATTRIB_ARRAY4_NV = 34388 # GL/glext.h:3800
GL_VERTEX_ATTRIB_ARRAY5_NV = 34389 # GL/glext.h:3801
GL_VERTEX_ATTRIB_ARRAY6_NV = 34390 # GL/glext.h:3802
GL_VERTEX_ATTRIB_ARRAY7_NV = 34391 # GL/glext.h:3803
GL_VERTEX_ATTRIB_ARRAY8_NV = 34392 # GL/glext.h:3804
GL_VERTEX_ATTRIB_ARRAY9_NV = 34393 # GL/glext.h:3805
GL_VERTEX_ATTRIB_ARRAY10_NV = 34394 # GL/glext.h:3806
GL_VERTEX_ATTRIB_ARRAY11_NV = 34395 # GL/glext.h:3807
GL_VERTEX_ATTRIB_ARRAY12_NV = 34396 # GL/glext.h:3808
GL_VERTEX_ATTRIB_ARRAY13_NV = 34397 # GL/glext.h:3809
GL_VERTEX_ATTRIB_ARRAY14_NV = 34398 # GL/glext.h:3810
GL_VERTEX_ATTRIB_ARRAY15_NV = 34399 # GL/glext.h:3811
GL_MAP1_VERTEX_ATTRIB0_4_NV = 34400 # GL/glext.h:3812
GL_MAP1_VERTEX_ATTRIB1_4_NV = 34401 # GL/glext.h:3813
GL_MAP1_VERTEX_ATTRIB2_4_NV = 34402 # GL/glext.h:3814
GL_MAP1_VERTEX_ATTRIB3_4_NV = 34403 # GL/glext.h:3815
GL_MAP1_VERTEX_ATTRIB4_4_NV = 34404 # GL/glext.h:3816
GL_MAP1_VERTEX_ATTRIB5_4_NV = 34405 # GL/glext.h:3817
GL_MAP1_VERTEX_ATTRIB6_4_NV = 34406 # GL/glext.h:3818
GL_MAP1_VERTEX_ATTRIB7_4_NV = 34407 # GL/glext.h:3819
GL_MAP1_VERTEX_ATTRIB8_4_NV = 34408 # GL/glext.h:3820
GL_MAP1_VERTEX_ATTRIB9_4_NV = 34409 # GL/glext.h:3821
GL_MAP1_VERTEX_ATTRIB10_4_NV = 34410 # GL/glext.h:3822
GL_MAP1_VERTEX_ATTRIB11_4_NV = 34411 # GL/glext.h:3823
GL_MAP1_VERTEX_ATTRIB12_4_NV = 34412 # GL/glext.h:3824
GL_MAP1_VERTEX_ATTRIB13_4_NV = 34413 # GL/glext.h:3825
GL_MAP1_VERTEX_ATTRIB14_4_NV = 34414 # GL/glext.h:3826
GL_MAP1_VERTEX_ATTRIB15_4_NV = 34415 # GL/glext.h:3827
GL_MAP2_VERTEX_ATTRIB0_4_NV = 34416 # GL/glext.h:3828
GL_MAP2_VERTEX_ATTRIB1_4_NV = 34417 # GL/glext.h:3829
GL_MAP2_VERTEX_ATTRIB2_4_NV = 34418 # GL/glext.h:3830
GL_MAP2_VERTEX_ATTRIB3_4_NV = 34419 # GL/glext.h:3831
GL_MAP2_VERTEX_ATTRIB4_4_NV = 34420 # GL/glext.h:3832
GL_MAP2_VERTEX_ATTRIB5_4_NV = 34421 # GL/glext.h:3833
GL_MAP2_VERTEX_ATTRIB6_4_NV = 34422 # GL/glext.h:3834
GL_MAP2_VERTEX_ATTRIB7_4_NV = 34423 # GL/glext.h:3835
GL_MAP2_VERTEX_ATTRIB8_4_NV = 34424 # GL/glext.h:3836
GL_MAP2_VERTEX_ATTRIB9_4_NV = 34425 # GL/glext.h:3837
GL_MAP2_VERTEX_ATTRIB10_4_NV = 34426 # GL/glext.h:3838
GL_MAP2_VERTEX_ATTRIB11_4_NV = 34427 # GL/glext.h:3839
GL_MAP2_VERTEX_ATTRIB12_4_NV = 34428 # GL/glext.h:3840
GL_MAP2_VERTEX_ATTRIB13_4_NV = 34429 # GL/glext.h:3841
GL_MAP2_VERTEX_ATTRIB14_4_NV = 34430 # GL/glext.h:3842
GL_MAP2_VERTEX_ATTRIB15_4_NV = 34431 # GL/glext.h:3843
# SGIX_texture_coordinate_clamp (GL/glext.h:3846)
GL_TEXTURE_MAX_CLAMP_S_SGIX = 33641 # GL/glext.h:3847
GL_TEXTURE_MAX_CLAMP_T_SGIX = 33642 # GL/glext.h:3848
GL_TEXTURE_MAX_CLAMP_R_SGIX = 33643 # GL/glext.h:3849
# SGIX_scalebias_hint (GL/glext.h:3852)
GL_SCALEBIAS_HINT_SGIX = 33570 # GL/glext.h:3853
# OML_interlace (GL/glext.h:3856)
GL_INTERLACE_OML = 35200 # GL/glext.h:3857
GL_INTERLACE_READ_OML = 35201 # GL/glext.h:3858
# OML_subsample (GL/glext.h:3861)
GL_FORMAT_SUBSAMPLE_24_24_OML = 35202 # GL/glext.h:3862
GL_FORMAT_SUBSAMPLE_244_244_OML = 35203 # GL/glext.h:3863
# OML_resample (GL/glext.h:3866)
GL_PACK_RESAMPLE_OML = 35204 # GL/glext.h:3867
GL_UNPACK_RESAMPLE_OML = 35205 # GL/glext.h:3868
GL_RESAMPLE_REPLICATE_OML = 35206 # GL/glext.h:3869
GL_RESAMPLE_ZERO_FILL_OML = 35207 # GL/glext.h:3870
GL_RESAMPLE_AVERAGE_OML = 35208 # GL/glext.h:3871
GL_RESAMPLE_DECIMATE_OML = 35209 # GL/glext.h:3872
# NV_copy_depth_to_color (GL/glext.h:3875)
GL_DEPTH_STENCIL_TO_RGBA_NV = 34926 # GL/glext.h:3876
GL_DEPTH_STENCIL_TO_BGRA_NV = 34927 # GL/glext.h:3877
# ATI_envmap_bumpmap (GL/glext.h:3880)
GL_BUMP_ROT_MATRIX_ATI = 34677 # GL/glext.h:3881
GL_BUMP_ROT_MATRIX_SIZE_ATI = 34678 # GL/glext.h:3882
GL_BUMP_NUM_TEX_UNITS_ATI = 34679 # GL/glext.h:3883
GL_BUMP_TEX_UNITS_ATI = 34680 # GL/glext.h:3884
GL_DUDV_ATI = 34681 # GL/glext.h:3885
GL_DU8DV8_ATI = 34682 # GL/glext.h:3886
GL_BUMP_ENVMAP_ATI = 34683 # GL/glext.h:3887
GL_BUMP_TARGET_ATI = 34684 # GL/glext.h:3888
# ATI_fragment_shader (GL/glext.h:3891)
GL_FRAGMENT_SHADER_ATI = 35104 # GL/glext.h:3892
GL_REG_0_ATI = 35105 # GL/glext.h:3893
GL_REG_1_ATI = 35106 # GL/glext.h:3894
GL_REG_2_ATI = 35107 # GL/glext.h:3895
GL_REG_3_ATI = 35108 # GL/glext.h:3896
GL_REG_4_ATI = 35109 # GL/glext.h:3897
GL_REG_5_ATI = 35110 # GL/glext.h:3898
GL_REG_6_ATI = 35111 # GL/glext.h:3899
GL_REG_7_ATI = 35112 # GL/glext.h:3900
GL_REG_8_ATI = 35113 # GL/glext.h:3901
GL_REG_9_ATI = 35114 # GL/glext.h:3902
GL_REG_10_ATI = 35115 # GL/glext.h:3903
GL_REG_11_ATI = 35116 # GL/glext.h:3904
GL_REG_12_ATI = 35117 # GL/glext.h:3905
GL_REG_13_ATI = 35118 # GL/glext.h:3906
GL_REG_14_ATI = 35119 # GL/glext.h:3907
GL_REG_15_ATI = 35120 # GL/glext.h:3908
GL_REG_16_ATI = 35121 # GL/glext.h:3909
GL_REG_17_ATI = 35122 # GL/glext.h:3910
GL_REG_18_ATI = 35123 # GL/glext.h:3911
GL_REG_19_ATI = 35124 # GL/glext.h:3912
GL_REG_20_ATI = 35125 # GL/glext.h:3913
GL_REG_21_ATI = 35126 # GL/glext.h:3914
GL_REG_22_ATI = 35127 # GL/glext.h:3915
GL_REG_23_ATI = 35128 # GL/glext.h:3916
GL_REG_24_ATI = 35129 # GL/glext.h:3917
GL_REG_25_ATI = 35130 # GL/glext.h:3918
GL_REG_26_ATI = 35131 # GL/glext.h:3919
GL_REG_27_ATI = 35132 # GL/glext.h:3920
GL_REG_28_ATI = 35133 # GL/glext.h:3921
GL_REG_29_ATI = 35134 # GL/glext.h:3922
GL_REG_30_ATI = 35135 # GL/glext.h:3923
GL_REG_31_ATI = 35136 # GL/glext.h:3924
GL_CON_0_ATI = 35137 # GL/glext.h:3925
GL_CON_1_ATI = 35138 # GL/glext.h:3926
GL_CON_2_ATI = 35139 # GL/glext.h:3927
GL_CON_3_ATI = 35140 # GL/glext.h:3928
GL_CON_4_ATI = 35141 # GL/glext.h:3929
GL_CON_5_ATI = 35142 # GL/glext.h:3930
GL_CON_6_ATI = 35143 # GL/glext.h:3931
GL_CON_7_ATI = 35144 # GL/glext.h:3932
GL_CON_8_ATI = 35145 # GL/glext.h:3933
GL_CON_9_ATI = 35146 # GL/glext.h:3934
GL_CON_10_ATI = 35147 # GL/glext.h:3935
GL_CON_11_ATI = 35148 # GL/glext.h:3936
GL_CON_12_ATI = 35149 # GL/glext.h:3937
GL_CON_13_ATI = 35150 # GL/glext.h:3938
GL_CON_14_ATI = 35151 # GL/glext.h:3939
GL_CON_15_ATI = 35152 # GL/glext.h:3940
GL_CON_16_ATI = 35153 # GL/glext.h:3941
GL_CON_17_ATI = 35154 # GL/glext.h:3942
GL_CON_18_ATI = 35155 # GL/glext.h:3943
GL_CON_19_ATI = 35156 # GL/glext.h:3944
GL_CON_20_ATI = 35157 # GL/glext.h:3945
GL_CON_21_ATI = 35158 # GL/glext.h:3946
GL_CON_22_ATI = 35159 # GL/glext.h:3947
GL_CON_23_ATI = 35160 # GL/glext.h:3948
GL_CON_24_ATI = 35161 # GL/glext.h:3949
GL_CON_25_ATI = 35162 # GL/glext.h:3950
GL_CON_26_ATI = 35163 # GL/glext.h:3951
GL_CON_27_ATI = 35164 # GL/glext.h:3952
GL_CON_28_ATI = 35165 # GL/glext.h:3953
GL_CON_29_ATI = 35166 # GL/glext.h:3954
GL_CON_30_ATI = 35167 # GL/glext.h:3955
GL_CON_31_ATI = 35168 # GL/glext.h:3956
GL_MOV_ATI = 35169 # GL/glext.h:3957
GL_ADD_ATI = 35171 # GL/glext.h:3958
GL_MUL_ATI = 35172 # GL/glext.h:3959
GL_SUB_ATI = 35173 # GL/glext.h:3960
GL_DOT3_ATI = 35174 # GL/glext.h:3961
GL_DOT4_ATI = 35175 # GL/glext.h:3962
GL_MAD_ATI = 35176 # GL/glext.h:3963
GL_LERP_ATI = 35177 # GL/glext.h:3964
GL_CND_ATI = 35178 # GL/glext.h:3965
GL_CND0_ATI = 35179 # GL/glext.h:3966
GL_DOT2_ADD_ATI = 35180 # GL/glext.h:3967
GL_SECONDARY_INTERPOLATOR_ATI = 35181 # GL/glext.h:3968
GL_NUM_FRAGMENT_REGISTERS_ATI = 35182 # GL/glext.h:3969
GL_NUM_FRAGMENT_CONSTANTS_ATI = 35183 # GL/glext.h:3970
GL_NUM_PASSES_ATI = 35184 # GL/glext.h:3971
GL_NUM_INSTRUCTIONS_PER_PASS_ATI = 35185 # GL/glext.h:3972
GL_NUM_INSTRUCTIONS_TOTAL_ATI = 35186 # GL/glext.h:3973
GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 35187 # GL/glext.h:3974
GL_NUM_LOOPBACK_COMPONENTS_ATI = 35188 # GL/glext.h:3975
GL_COLOR_ALPHA_PAIRING_ATI = 35189 # GL/glext.h:3976
GL_SWIZZLE_STR_ATI = 35190 # GL/glext.h:3977
GL_SWIZZLE_STQ_ATI = 35191 # GL/glext.h:3978
GL_SWIZZLE_STR_DR_ATI = 35192 # GL/glext.h:3979
GL_SWIZZLE_STQ_DQ_ATI = 35193 # GL/glext.h:3980
GL_SWIZZLE_STRQ_ATI = 35194 # GL/glext.h:3981
GL_SWIZZLE_STRQ_DQ_ATI = 35195 # GL/glext.h:3982
GL_RED_BIT_ATI = 1 # GL/glext.h:3983
GL_GREEN_BIT_ATI = 2 # GL/glext.h:3984
GL_BLUE_BIT_ATI = 4 # GL/glext.h:3985
GL_2X_BIT_ATI = 1 # GL/glext.h:3986
GL_4X_BIT_ATI = 2 # GL/glext.h:3987
GL_8X_BIT_ATI = 4 # GL/glext.h:3988
GL_HALF_BIT_ATI = 8 # GL/glext.h:3989
GL_QUARTER_BIT_ATI = 16 # GL/glext.h:3990
GL_EIGHTH_BIT_ATI = 32 # GL/glext.h:3991
GL_SATURATE_BIT_ATI = 64 # GL/glext.h:3992
GL_COMP_BIT_ATI = 2 # GL/glext.h:3993
GL_NEGATE_BIT_ATI = 4 # GL/glext.h:3994
GL_BIAS_BIT_ATI = 8 # GL/glext.h:3995
# ATI_pn_triangles (GL/glext.h:3998)
GL_PN_TRIANGLES_ATI = 34800 # GL/glext.h:3999
GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34801 # GL/glext.h:4000
GL_PN_TRIANGLES_POINT_MODE_ATI = 34802 # GL/glext.h:4001
GL_PN_TRIANGLES_NORMAL_MODE_ATI = 34803 # GL/glext.h:4002
GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34804 # GL/glext.h:4003
GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 34805 # GL/glext.h:4004
GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 34806 # GL/glext.h:4005
GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 34807 # GL/glext.h:4006
GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 34808 # GL/glext.h:4007
# ATI_vertex_array_object (GL/glext.h:4010)
GL_STATIC_ATI = 34656 # GL/glext.h:4011
GL_DYNAMIC_ATI = 34657 # GL/glext.h:4012
GL_PRESERVE_ATI = 34658 # GL/glext.h:4013
GL_DISCARD_ATI = 34659 # GL/glext.h:4014
GL_OBJECT_BUFFER_SIZE_ATI = 34660 # GL/glext.h:4015
GL_OBJECT_BUFFER_USAGE_ATI = 34661 # GL/glext.h:4016
GL_ARRAY_OBJECT_BUFFER_ATI = 34662 # GL/glext.h:4017
GL_ARRAY_OBJECT_OFFSET_ATI = 34663 # GL/glext.h:4018
# EXT_vertex_shader (GL/glext.h:4021)
GL_VERTEX_SHADER_EXT = 34688 # GL/glext.h:4022
GL_VERTEX_SHADER_BINDING_EXT = 34689 # GL/glext.h:4023
GL_OP_INDEX_EXT = 34690 # GL/glext.h:4024
GL_OP_NEGATE_EXT = 34691 # GL/glext.h:4025
GL_OP_DOT3_EXT = 34692 # GL/glext.h:4026
GL_OP_DOT4_EXT = 34693 # GL/glext.h:4027
GL_OP_MUL_EXT = 34694 # GL/glext.h:4028
GL_OP_ADD_EXT = 34695 # GL/glext.h:4029
GL_OP_MADD_EXT = 34696 # GL/glext.h:4030
GL_OP_FRAC_EXT = 34697 # GL/glext.h:4031
GL_OP_MAX_EXT = 34698 # GL/glext.h:4032
GL_OP_MIN_EXT = 34699 # GL/glext.h:4033
GL_OP_SET_GE_EXT = 34700 # GL/glext.h:4034
GL_OP_SET_LT_EXT = 34701 # GL/glext.h:4035
GL_OP_CLAMP_EXT = 34702 # GL/glext.h:4036
GL_OP_FLOOR_EXT = 34703 # GL/glext.h:4037
GL_OP_ROUND_EXT = 34704 # GL/glext.h:4038
GL_OP_EXP_BASE_2_EXT = 34705 # GL/glext.h:4039
GL_OP_LOG_BASE_2_EXT = 34706 # GL/glext.h:4040
GL_OP_POWER_EXT = 34707 # GL/glext.h:4041
GL_OP_RECIP_EXT = 34708 # GL/glext.h:4042
GL_OP_RECIP_SQRT_EXT = 34709 # GL/glext.h:4043
GL_OP_SUB_EXT = 34710 # GL/glext.h:4044
GL_OP_CROSS_PRODUCT_EXT = 34711 # GL/glext.h:4045
GL_OP_MULTIPLY_MATRIX_EXT = 34712 # GL/glext.h:4046
GL_OP_MOV_EXT = 34713 # GL/glext.h:4047
GL_OUTPUT_VERTEX_EXT = 34714 # GL/glext.h:4048
GL_OUTPUT_COLOR0_EXT = 34715 # GL/glext.h:4049
GL_OUTPUT_COLOR1_EXT = 34716 # GL/glext.h:4050
GL_OUTPUT_TEXTURE_COORD0_EXT = 34717 # GL/glext.h:4051
GL_OUTPUT_TEXTURE_COORD1_EXT = 34718 # GL/glext.h:4052
GL_OUTPUT_TEXTURE_COORD2_EXT = 34719 # GL/glext.h:4053
GL_OUTPUT_TEXTURE_COORD3_EXT = 34720 # GL/glext.h:4054
GL_OUTPUT_TEXTURE_COORD4_EXT = 34721 # GL/glext.h:4055
GL_OUTPUT_TEXTURE_COORD5_EXT = 34722 # GL/glext.h:4056
GL_OUTPUT_TEXTURE_COORD6_EXT = 34723 # GL/glext.h:4057
GL_OUTPUT_TEXTURE_COORD7_EXT = 34724 # GL/glext.h:4058
GL_OUTPUT_TEXTURE_COORD8_EXT = 34725 # GL/glext.h:4059
GL_OUTPUT_TEXTURE_COORD9_EXT = 34726 # GL/glext.h:4060
GL_OUTPUT_TEXTURE_COORD10_EXT = 34727 # GL/glext.h:4061
GL_OUTPUT_TEXTURE_COORD11_EXT = 34728 # GL/glext.h:4062
GL_OUTPUT_TEXTURE_COORD12_EXT = 34729 # GL/glext.h:4063
GL_OUTPUT_TEXTURE_COORD13_EXT = 34730 # GL/glext.h:4064
GL_OUTPUT_TEXTURE_COORD14_EXT = 34731 # GL/glext.h:4065
GL_OUTPUT_TEXTURE_COORD15_EXT = 34732 # GL/glext.h:4066
GL_OUTPUT_TEXTURE_COORD16_EXT = 34733 # GL/glext.h:4067
GL_OUTPUT_TEXTURE_COORD17_EXT = 34734 # GL/glext.h:4068
GL_OUTPUT_TEXTURE_COORD18_EXT = 34735 # GL/glext.h:4069
GL_OUTPUT_TEXTURE_COORD19_EXT = 34736 # GL/glext.h:4070
GL_OUTPUT_TEXTURE_COORD20_EXT = 34737 # GL/glext.h:4071
GL_OUTPUT_TEXTURE_COORD21_EXT = 34738 # GL/glext.h:4072
GL_OUTPUT_TEXTURE_COORD22_EXT = 34739 # GL/glext.h:4073
GL_OUTPUT_TEXTURE_COORD23_EXT = 34740 # GL/glext.h:4074
GL_OUTPUT_TEXTURE_COORD24_EXT = 34741 # GL/glext.h:4075
GL_OUTPUT_TEXTURE_COORD25_EXT = 34742 # GL/glext.h:4076
GL_OUTPUT_TEXTURE_COORD26_EXT = 34743 # GL/glext.h:4077
GL_OUTPUT_TEXTURE_COORD27_EXT = 34744 # GL/glext.h:4078
GL_OUTPUT_TEXTURE_COORD28_EXT = 34745 # GL/glext.h:4079
GL_OUTPUT_TEXTURE_COORD29_EXT = 34746 # GL/glext.h:4080
GL_OUTPUT_TEXTURE_COORD30_EXT = 34747 # GL/glext.h:4081
GL_OUTPUT_TEXTURE_COORD31_EXT = 34748 # GL/glext.h:4082
GL_OUTPUT_FOG_EXT = 34749 # GL/glext.h:4083
GL_SCALAR_EXT = 34750 # GL/glext.h:4084
GL_VECTOR_EXT = 34751 # GL/glext.h:4085
GL_MATRIX_EXT = 34752 # GL/glext.h:4086
GL_VARIANT_EXT = 34753 # GL/glext.h:4087
GL_INVARIANT_EXT = 34754 # GL/glext.h:4088
GL_LOCAL_CONSTANT_EXT = 34755 # GL/glext.h:4089
GL_LOCAL_EXT = 34756 # GL/glext.h:4090
GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 34757 # GL/glext.h:4091
GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 34758 # GL/glext.h:4092
GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 34759 # GL/glext.h:4093
GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34760 # GL/glext.h:4094
GL_MAX_VERTEX_SHADER_LOCALS_EXT = 34761 # GL/glext.h:4095
GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 34762 # GL/glext.h:4096
GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 34763 # GL/glext.h:4097
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34764 # GL/glext.h:4098
GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 34765 # GL/glext.h:4099
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 34766 # GL/glext.h:4100
GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 34767 # GL/glext.h:4101
GL_VERTEX_SHADER_VARIANTS_EXT = 34768 # GL/glext.h:4102
GL_VERTEX_SHADER_INVARIANTS_EXT = 34769 # GL/glext.h:4103
GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34770 # GL/glext.h:4104
GL_VERTEX_SHADER_LOCALS_EXT = 34771 # GL/glext.h:4105
GL_VERTEX_SHADER_OPTIMIZED_EXT = 34772 # GL/glext.h:4106
GL_X_EXT = 34773 # GL/glext.h:4107
GL_Y_EXT = 34774 # GL/glext.h:4108
GL_Z_EXT = 34775 # GL/glext.h:4109
GL_W_EXT = 34776 # GL/glext.h:4110
GL_NEGATIVE_X_EXT = 34777 # GL/glext.h:4111
GL_NEGATIVE_Y_EXT = 34778 # GL/glext.h:4112
GL_NEGATIVE_Z_EXT = 34779 # GL/glext.h:4113
GL_NEGATIVE_W_EXT = 34780 # GL/glext.h:4114
GL_ZERO_EXT = 34781 # GL/glext.h:4115
GL_ONE_EXT = 34782 # GL/glext.h:4116
GL_NEGATIVE_ONE_EXT = 34783 # GL/glext.h:4117
GL_NORMALIZED_RANGE_EXT = 34784 # GL/glext.h:4118
GL_FULL_RANGE_EXT = 34785 # GL/glext.h:4119
GL_CURRENT_VERTEX_EXT = 34786 # GL/glext.h:4120
GL_MVP_MATRIX_EXT = 34787 # GL/glext.h:4121
GL_VARIANT_VALUE_EXT = 34788 # GL/glext.h:4122
GL_VARIANT_DATATYPE_EXT = 34789 # GL/glext.h:4123
GL_VARIANT_ARRAY_STRIDE_EXT = 34790 # GL/glext.h:4124
GL_VARIANT_ARRAY_TYPE_EXT = 34791 # GL/glext.h:4125
GL_VARIANT_ARRAY_EXT = 34792 # GL/glext.h:4126
GL_VARIANT_ARRAY_POINTER_EXT = 34793 # GL/glext.h:4127
GL_INVARIANT_VALUE_EXT = 34794 # GL/glext.h:4128
GL_INVARIANT_DATATYPE_EXT = 34795 # GL/glext.h:4129
GL_LOCAL_CONSTANT_VALUE_EXT = 34796 # GL/glext.h:4130
GL_LOCAL_CONSTANT_DATATYPE_EXT = 34797 # GL/glext.h:4131
# ATI_vertex_streams (GL/glext.h:4134)
GL_MAX_VERTEX_STREAMS_ATI = 34667 # GL/glext.h:4135
GL_VERTEX_STREAM0_ATI = 34668 # GL/glext.h:4136
GL_VERTEX_STREAM1_ATI = 34669 # GL/glext.h:4137
GL_VERTEX_STREAM2_ATI = 34670 # GL/glext.h:4138
GL_VERTEX_STREAM3_ATI = 34671 # GL/glext.h:4139
GL_VERTEX_STREAM4_ATI = 34672 # GL/glext.h:4140
GL_VERTEX_STREAM5_ATI = 34673 # GL/glext.h:4141
GL_VERTEX_STREAM6_ATI = 34674 # GL/glext.h:4142
GL_VERTEX_STREAM7_ATI = 34675 # GL/glext.h:4143
GL_VERTEX_SOURCE_ATI = 34676 # GL/glext.h:4144
# ATI_element_array (GL/glext.h:4147)
GL_ELEMENT_ARRAY_ATI = 34664 # GL/glext.h:4148
GL_ELEMENT_ARRAY_TYPE_ATI = 34665 # GL/glext.h:4149
GL_ELEMENT_ARRAY_POINTER_ATI = 34666 # GL/glext.h:4150
# SUN_mesh_array (GL/glext.h:4153)
GL_QUAD_MESH_SUN = 34324 # GL/glext.h:4154
GL_TRIANGLE_MESH_SUN = 34325 # GL/glext.h:4155
# SUN_slice_accum (GL/glext.h:4158)
GL_SLICE_ACCUM_SUN = 34252 # GL/glext.h:4159
# NV_multisample_filter_hint (GL/glext.h:4162)
GL_MULTISAMPLE_FILTER_HINT_NV = 34100 # GL/glext.h:4163
# NV_depth_clamp (GL/glext.h:4166)
GL_DEPTH_CLAMP_NV = 34383 # GL/glext.h:4167
# NV_occlusion_query (GL/glext.h:4170)
GL_PIXEL_COUNTER_BITS_NV = 34916 # GL/glext.h:4171
GL_CURRENT_OCCLUSION_QUERY_ID_NV = 34917 # GL/glext.h:4172
GL_PIXEL_COUNT_NV = 34918 # GL/glext.h:4173
GL_PIXEL_COUNT_AVAILABLE_NV = 34919 # GL/glext.h:4174
# NV_point_sprite (GL/glext.h:4177)
GL_POINT_SPRITE_NV = 34913 # GL/glext.h:4178
GL_COORD_REPLACE_NV = 34914 # GL/glext.h:4179
GL_POINT_SPRITE_R_MODE_NV = 34915 # GL/glext.h:4180
# NV_texture_shader3 (GL/glext.h:4183)
GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 34896 # GL/glext.h:4184
GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 34897 # GL/glext.h:4185
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 34898 # GL/glext.h:4186
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 34899 # GL/glext.h:4187
GL_OFFSET_HILO_TEXTURE_2D_NV = 34900 # GL/glext.h:4188
GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 34901 # GL/glext.h:4189
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 34902 # GL/glext.h:4190
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 34903 # GL/glext.h:4191
GL_DEPENDENT_HILO_TEXTURE_2D_NV = 34904 # GL/glext.h:4192
GL_DEPENDENT_RGB_TEXTURE_3D_NV = 34905 # GL/glext.h:4193
GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 34906 # GL/glext.h:4194
GL_DOT_PRODUCT_PASS_THROUGH_NV = 34907 # GL/glext.h:4195
GL_DOT_PRODUCT_TEXTURE_1D_NV = 34908 # GL/glext.h:4196
GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 34909 # GL/glext.h:4197
GL_HILO8_NV = 34910 # GL/glext.h:4198
GL_SIGNED_HILO8_NV = 34911 # GL/glext.h:4199
GL_FORCE_BLUE_TO_ONE_NV = 34912 # GL/glext.h:4200
# NV_vertex_program1_1 (GL/glext.h:4203)
# EXT_shadow_funcs (GL/glext.h:4206)
# EXT_stencil_two_side (GL/glext.h:4209)
GL_STENCIL_TEST_TWO_SIDE_EXT = 35088 # GL/glext.h:4210
GL_ACTIVE_STENCIL_FACE_EXT = 35089 # GL/glext.h:4211
# ATI_text_fragment_shader (GL/glext.h:4214)
GL_TEXT_FRAGMENT_SHADER_ATI = 33280 # GL/glext.h:4215
# APPLE_client_storage (GL/glext.h:4218)
GL_UNPACK_CLIENT_STORAGE_APPLE = 34226 # GL/glext.h:4219
# APPLE_element_array (GL/glext.h:4222)
GL_ELEMENT_ARRAY_APPLE = 35340 # GL/glext.h:4223
GL_ELEMENT_ARRAY_TYPE_APPLE = 35341 # GL/glext.h:4224
GL_ELEMENT_ARRAY_POINTER_APPLE = 35342 # GL/glext.h:4225
# APPLE_fence (GL/glext.h:4228)
GL_DRAW_PIXELS_APPLE = 35338 # GL/glext.h:4229
GL_FENCE_APPLE = 35339 # GL/glext.h:4230
# APPLE_vertex_array_object (GL/glext.h:4233)
GL_VERTEX_ARRAY_BINDING_APPLE = 34229 # GL/glext.h:4234
# APPLE_vertex_array_range (GL/glext.h:4237)
GL_VERTEX_ARRAY_RANGE_APPLE = 34077 # GL/glext.h:4238
GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 34078 # GL/glext.h:4239
GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = 34079 # GL/glext.h:4240
GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = 34081 # GL/glext.h:4241
GL_STORAGE_CLIENT_APPLE = 34228 # GL/glext.h:4242
GL_STORAGE_CACHED_APPLE = 34238 # GL/glext.h:4243
GL_STORAGE_SHARED_APPLE = 34239 # GL/glext.h:4244
# APPLE_ycbcr_422 (GL/glext.h:4247)
GL_YCBCR_422_APPLE = 34233 # GL/glext.h:4248
GL_UNSIGNED_SHORT_8_8_APPLE = 34234 # GL/glext.h:4249
GL_UNSIGNED_SHORT_8_8_REV_APPLE = 34235 # GL/glext.h:4250
# S3_s3tc (GL/glext.h:4253)
GL_RGB_S3TC = 33696 # GL/glext.h:4254
GL_RGB4_S3TC = 33697 # GL/glext.h:4255
GL_RGBA_S3TC = 33698 # GL/glext.h:4256
GL_RGBA4_S3TC = 33699 # GL/glext.h:4257
# ATI_draw_buffers (GL/glext.h:4260)
GL_MAX_DRAW_BUFFERS_ATI = 34852 # GL/glext.h:4261
GL_DRAW_BUFFER0_ATI = 34853 # GL/glext.h:4262
GL_DRAW_BUFFER1_ATI = 34854 # GL/glext.h:4263
GL_DRAW_BUFFER2_ATI = 34855 # GL/glext.h:4264
GL_DRAW_BUFFER3_ATI = 34856 # GL/glext.h:4265
GL_DRAW_BUFFER4_ATI = 34857 # GL/glext.h:4266
GL_DRAW_BUFFER5_ATI = 34858 # GL/glext.h:4267
GL_DRAW_BUFFER6_ATI = 34859 # GL/glext.h:4268
GL_DRAW_BUFFER7_ATI = 34860 # GL/glext.h:4269
GL_DRAW_BUFFER8_ATI = 34861 # GL/glext.h:4270
GL_DRAW_BUFFER9_ATI = 34862 # GL/glext.h:4271
GL_DRAW_BUFFER10_ATI = 34863 # GL/glext.h:4272
GL_DRAW_BUFFER11_ATI = 34864 # GL/glext.h:4273
GL_DRAW_BUFFER12_ATI = 34865 # GL/glext.h:4274
GL_DRAW_BUFFER13_ATI = 34866 # GL/glext.h:4275
GL_DRAW_BUFFER14_ATI = 34867 # GL/glext.h:4276
GL_DRAW_BUFFER15_ATI = 34868 # GL/glext.h:4277
# ATI_pixel_format_float (GL/glext.h:4280)
GL_TYPE_RGBA_FLOAT_ATI = 34848 # GL/glext.h:4281
GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 34869 # GL/glext.h:4282
# ATI_texture_env_combine3 (GL/glext.h:4285)
GL_MODULATE_ADD_ATI = 34628 # GL/glext.h:4286
GL_MODULATE_SIGNED_ADD_ATI = 34629 # GL/glext.h:4287
GL_MODULATE_SUBTRACT_ATI = 34630 # GL/glext.h:4288
# ATI_texture_float (GL/glext.h:4291)
GL_RGBA_FLOAT32_ATI = 34836 # GL/glext.h:4292
GL_RGB_FLOAT32_ATI = 34837 # GL/glext.h:4293
GL_ALPHA_FLOAT32_ATI = 34838 # GL/glext.h:4294
GL_INTENSITY_FLOAT32_ATI = 34839 # GL/glext.h:4295
GL_LUMINANCE_FLOAT32_ATI = 34840 # GL/glext.h:4296
GL_LUMINANCE_ALPHA_FLOAT32_ATI = 34841 # GL/glext.h:4297
GL_RGBA_FLOAT16_ATI = 34842 # GL/glext.h:4298
GL_RGB_FLOAT16_ATI = 34843 # GL/glext.h:4299
GL_ALPHA_FLOAT16_ATI = 34844 # GL/glext.h:4300
GL_INTENSITY_FLOAT16_ATI = 34845 # GL/glext.h:4301
GL_LUMINANCE_FLOAT16_ATI = 34846 # GL/glext.h:4302
GL_LUMINANCE_ALPHA_FLOAT16_ATI = 34847 # GL/glext.h:4303
# NV_float_buffer (GL/glext.h:4306)
GL_FLOAT_R_NV = 34944 # GL/glext.h:4307
GL_FLOAT_RG_NV = 34945 # GL/glext.h:4308
GL_FLOAT_RGB_NV = 34946 # GL/glext.h:4309
GL_FLOAT_RGBA_NV = 34947 # GL/glext.h:4310
GL_FLOAT_R16_NV = 34948 # GL/glext.h:4311
GL_FLOAT_R32_NV = 34949 # GL/glext.h:4312
GL_FLOAT_RG16_NV = 34950 # GL/glext.h:4313
GL_FLOAT_RG32_NV = 34951 # GL/glext.h:4314
GL_FLOAT_RGB16_NV = 34952 # GL/glext.h:4315
GL_FLOAT_RGB32_NV = 34953 # GL/glext.h:4316
GL_FLOAT_RGBA16_NV = 34954 # GL/glext.h:4317
GL_FLOAT_RGBA32_NV = 34955 # GL/glext.h:4318
GL_TEXTURE_FLOAT_COMPONENTS_NV = 34956 # GL/glext.h:4319
GL_FLOAT_CLEAR_COLOR_VALUE_NV = 34957 # GL/glext.h:4320
GL_FLOAT_RGBA_MODE_NV = 34958 # GL/glext.h:4321
# NV_fragment_program (GL/glext.h:4324)
GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 34920 # GL/glext.h:4325
GL_FRAGMENT_PROGRAM_NV = 34928 # GL/glext.h:4326
GL_MAX_TEXTURE_COORDS_NV = 34929 # GL/glext.h:4327
GL_MAX_TEXTURE_IMAGE_UNITS_NV = 34930 # GL/glext.h:4328
GL_FRAGMENT_PROGRAM_BINDING_NV = 34931 # GL/glext.h:4329
GL_PROGRAM_ERROR_STRING_NV = 34932 # GL/glext.h:4330
# NV_half_float (GL/glext.h:4333)
GL_HALF_FLOAT_NV = 5131 # GL/glext.h:4334
# NV_pixel_data_range (GL/glext.h:4337)
GL_WRITE_PIXEL_DATA_RANGE_NV = 34936 # GL/glext.h:4338
GL_READ_PIXEL_DATA_RANGE_NV = 34937 # GL/glext.h:4339
GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 34938 # GL/glext.h:4340
GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = 34939 # GL/glext.h:4341
GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 34940 # GL/glext.h:4342
GL_READ_PIXEL_DATA_RANGE_POINTER_NV = 34941 # GL/glext.h:4343
# NV_primitive_restart (GL/glext.h:4346)
GL_PRIMITIVE_RESTART_NV = 34136 # GL/glext.h:4347
GL_PRIMITIVE_RESTART_INDEX_NV = 34137 # GL/glext.h:4348
# NV_texture_expand_normal (GL/glext.h:4351)
GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = 34959 # GL/glext.h:4352
# NV_vertex_program2 (GL/glext.h:4355)
# ATI_map_object_buffer (GL/glext.h:4358)
# ATI_separate_stencil (GL/glext.h:4361)
GL_STENCIL_BACK_FUNC_ATI = 34816 # GL/glext.h:4362
GL_STENCIL_BACK_FAIL_ATI = 34817 # GL/glext.h:4363
GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 34818 # GL/glext.h:4364
GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 34819 # GL/glext.h:4365
# ATI_vertex_attrib_array_object (GL/glext.h:4368)
# OES_read_format (GL/glext.h:4371)
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 35738 # GL/glext.h:4372
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 35739 # GL/glext.h:4373
# EXT_depth_bounds_test (GL/glext.h:4376)
GL_DEPTH_BOUNDS_TEST_EXT = 34960 # GL/glext.h:4377
GL_DEPTH_BOUNDS_EXT = 34961 # GL/glext.h:4378
# EXT_texture_mirror_clamp (GL/glext.h:4381)
GL_MIRROR_CLAMP_EXT = 34626 # GL/glext.h:4382
GL_MIRROR_CLAMP_TO_EDGE_EXT = 34627 # GL/glext.h:4383
GL_MIRROR_CLAMP_TO_BORDER_EXT = 35090 # GL/glext.h:4384
# EXT_blend_equation_separate (GL/glext.h:4387)
GL_BLEND_EQUATION_RGB_EXT = 32777 # GL/glext.h:4388
GL_BLEND_EQUATION_ALPHA_EXT = 34877 # GL/glext.h:4389
# MESA_pack_invert (GL/glext.h:4392)
GL_PACK_INVERT_MESA = 34648 # GL/glext.h:4393
# MESA_ycbcr_texture (GL/glext.h:4396)
GL_UNSIGNED_SHORT_8_8_MESA = 34234 # GL/glext.h:4397
GL_UNSIGNED_SHORT_8_8_REV_MESA = 34235 # GL/glext.h:4398
GL_YCBCR_MESA = 34647 # GL/glext.h:4399
# EXT_pixel_buffer_object (GL/glext.h:4402)
GL_PIXEL_PACK_BUFFER_EXT = 35051 # GL/glext.h:4403
GL_PIXEL_UNPACK_BUFFER_EXT = 35052 # GL/glext.h:4404
GL_PIXEL_PACK_BUFFER_BINDING_EXT = 35053 # GL/glext.h:4405
GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = 35055 # GL/glext.h:4406
# NV_fragment_program_option (GL/glext.h:4409)
# NV_fragment_program2 (GL/glext.h:4412)
GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 35060 # GL/glext.h:4413
GL_MAX_PROGRAM_CALL_DEPTH_NV = 35061 # GL/glext.h:4414
GL_MAX_PROGRAM_IF_DEPTH_NV = 35062 # GL/glext.h:4415
GL_MAX_PROGRAM_LOOP_DEPTH_NV = 35063 # GL/glext.h:4416
GL_MAX_PROGRAM_LOOP_COUNT_NV = 35064 # GL/glext.h:4417
# NV_vertex_program2_option (GL/glext.h:4420)
# NV_vertex_program3 (GL/glext.h:4425)
# EXT_framebuffer_object (GL/glext.h:4429)
GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 1286 # GL/glext.h:4430
GL_MAX_RENDERBUFFER_SIZE_EXT = 34024 # GL/glext.h:4431
GL_FRAMEBUFFER_BINDING_EXT = 36006 # GL/glext.h:4432
GL_RENDERBUFFER_BINDING_EXT = 36007 # GL/glext.h:4433
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 36048 # GL/glext.h:4434
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 36049 # GL/glext.h:4435
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 36050 # GL/glext.h:4436
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 36051 # GL/glext.h:4437
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 36052 # GL/glext.h:4438
GL_FRAMEBUFFER_COMPLETE_EXT = 36053 # GL/glext.h:4439
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 36054 # GL/glext.h:4440
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 36055 # GL/glext.h:4441
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 36057 # GL/glext.h:4442
GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 36058 # GL/glext.h:4443
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 36059 # GL/glext.h:4444
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 36060 # GL/glext.h:4445
GL_FRAMEBUFFER_UNSUPPORTED_EXT = 36061 # GL/glext.h:4446
GL_MAX_COLOR_ATTACHMENTS_EXT = 36063 # GL/glext.h:4447
GL_COLOR_ATTACHMENT0_EXT = 36064 # GL/glext.h:4448
GL_COLOR_ATTACHMENT1_EXT = 36065 # GL/glext.h:4449
GL_COLOR_ATTACHMENT2_EXT = 36066 # GL/glext.h:4450
GL_COLOR_ATTACHMENT3_EXT = 36067 # GL/glext.h:4451
GL_COLOR_ATTACHMENT4_EXT = 36068 # GL/glext.h:4452
GL_COLOR_ATTACHMENT5_EXT = 36069 # GL/glext.h:4453
GL_COLOR_ATTACHMENT6_EXT = 36070 # GL/glext.h:4454
GL_COLOR_ATTACHMENT7_EXT = 36071 # GL/glext.h:4455
GL_COLOR_ATTACHMENT8_EXT = 36072 # GL/glext.h:4456
GL_COLOR_ATTACHMENT9_EXT = 36073 # GL/glext.h:4457
GL_COLOR_ATTACHMENT10_EXT = 36074 # GL/glext.h:4458
GL_COLOR_ATTACHMENT11_EXT = 36075 # GL/glext.h:4459
GL_COLOR_ATTACHMENT12_EXT = 36076 # GL/glext.h:4460
GL_COLOR_ATTACHMENT13_EXT = 36077 # GL/glext.h:4461
GL_COLOR_ATTACHMENT14_EXT = 36078 # GL/glext.h:4462
GL_COLOR_ATTACHMENT15_EXT = 36079 # GL/glext.h:4463
GL_DEPTH_ATTACHMENT_EXT = 36096 # GL/glext.h:4464
GL_STENCIL_ATTACHMENT_EXT = 36128 # GL/glext.h:4465
GL_FRAMEBUFFER_EXT = 36160 # GL/glext.h:4466
GL_RENDERBUFFER_EXT = 36161 # GL/glext.h:4467
GL_RENDERBUFFER_WIDTH_EXT = 36162 # GL/glext.h:4468
GL_RENDERBUFFER_HEIGHT_EXT = 36163 # GL/glext.h:4469
GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 36164 # GL/glext.h:4470
GL_STENCIL_INDEX1_EXT = 36166 # GL/glext.h:4471
GL_STENCIL_INDEX4_EXT = 36167 # GL/glext.h:4472
GL_STENCIL_INDEX8_EXT = 36168 # GL/glext.h:4473
GL_STENCIL_INDEX16_EXT = 36169 # GL/glext.h:4474
GL_RENDERBUFFER_RED_SIZE_EXT = 36176 # GL/glext.h:4475
GL_RENDERBUFFER_GREEN_SIZE_EXT = 36177 # GL/glext.h:4476
GL_RENDERBUFFER_BLUE_SIZE_EXT = 36178 # GL/glext.h:4477
GL_RENDERBUFFER_ALPHA_SIZE_EXT = 36179 # GL/glext.h:4478
GL_RENDERBUFFER_DEPTH_SIZE_EXT = 36180 # GL/glext.h:4479
GL_RENDERBUFFER_STENCIL_SIZE_EXT = 36181 # GL/glext.h:4480
# GREMEDY_string_marker (GL/glext.h:4483)
# EXT_packed_depth_stencil (GL/glext.h:4486)
GL_DEPTH_STENCIL_EXT = 34041 # GL/glext.h:4487
GL_UNSIGNED_INT_24_8_EXT = 34042 # GL/glext.h:4488
GL_DEPTH24_STENCIL8_EXT = 35056 # GL/glext.h:4489
GL_TEXTURE_STENCIL_SIZE_EXT = 35057 # GL/glext.h:4490
# EXT_stencil_clear_tag (GL/glext.h:4493)
GL_STENCIL_TAG_BITS_EXT = 35058 # GL/glext.h:4494
GL_STENCIL_CLEAR_TAG_VALUE_EXT = 35059 # GL/glext.h:4495
# EXT_texture_sRGB (GL/glext.h:4498)
GL_SRGB_EXT = 35904 # GL/glext.h:4499
GL_SRGB8_EXT = 35905 # GL/glext.h:4500
GL_SRGB_ALPHA_EXT = 35906 # GL/glext.h:4501
GL_SRGB8_ALPHA8_EXT = 35907 # GL/glext.h:4502
GL_SLUMINANCE_ALPHA_EXT = 35908 # GL/glext.h:4503
GL_SLUMINANCE8_ALPHA8_EXT = 35909 # GL/glext.h:4504
GL_SLUMINANCE_EXT = 35910 # GL/glext.h:4505
GL_SLUMINANCE8_EXT = 35911 # GL/glext.h:4506
GL_COMPRESSED_SRGB_EXT = 35912 # GL/glext.h:4507
GL_COMPRESSED_SRGB_ALPHA_EXT = 35913 # GL/glext.h:4508
GL_COMPRESSED_SLUMINANCE_EXT = 35914 # GL/glext.h:4509
GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = 35915 # GL/glext.h:4510
GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 35916 # GL/glext.h:4511
GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 35917 # GL/glext.h:4512
GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 35918 # GL/glext.h:4513
GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 35919 # GL/glext.h:4514
# EXT_framebuffer_blit (GL/glext.h:4517)
GL_READ_FRAMEBUFFER_EXT = 36008 # GL/glext.h:4518
GL_DRAW_FRAMEBUFFER_EXT = 36009 # GL/glext.h:4519
GL_DRAW_FRAMEBUFFER_BINDING_EXT = 36006 # GL/glext.h:4520
GL_READ_FRAMEBUFFER_BINDING_EXT = 36010 # GL/glext.h:4521
# EXT_framebuffer_multisample (GL/glext.h:4524)
GL_RENDERBUFFER_SAMPLES_EXT = 36011 # GL/glext.h:4525
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 36182 # GL/glext.h:4526
GL_MAX_SAMPLES_EXT = 36183 # GL/glext.h:4527
# MESAX_texture_stack (GL/glext.h:4530)
GL_TEXTURE_1D_STACK_MESAX = 34649 # GL/glext.h:4531
GL_TEXTURE_2D_STACK_MESAX = 34650 # GL/glext.h:4532
GL_PROXY_TEXTURE_1D_STACK_MESAX = 34651 # GL/glext.h:4533
GL_PROXY_TEXTURE_2D_STACK_MESAX = 34652 # GL/glext.h:4534
GL_TEXTURE_1D_STACK_BINDING_MESAX = 34653 # GL/glext.h:4535
GL_TEXTURE_2D_STACK_BINDING_MESAX = 34654 # GL/glext.h:4536
# EXT_timer_query (GL/glext.h:4539)
GL_TIME_ELAPSED_EXT = 35007 # GL/glext.h:4540
# EXT_gpu_program_parameters (GL/glext.h:4543)
# APPLE_flush_buffer_range (GL/glext.h:4546)
GL_BUFFER_SERIALIZED_MODIFY_APPLE = 35346 # GL/glext.h:4547
GL_BUFFER_FLUSHING_UNMAP_APPLE = 35347 # GL/glext.h:4548
# NV_gpu_program4 (GL/glext.h:4551)
GL_MIN_PROGRAM_TEXEL_OFFSET_NV = 35076 # GL/glext.h:4552
GL_MAX_PROGRAM_TEXEL_OFFSET_NV = 35077 # GL/glext.h:4553
GL_PROGRAM_ATTRIB_COMPONENTS_NV = 35078 # GL/glext.h:4554
GL_PROGRAM_RESULT_COMPONENTS_NV = 35079 # GL/glext.h:4555
GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 35080 # GL/glext.h:4556
GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 35081 # GL/glext.h:4557
GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 36261 # GL/glext.h:4558
GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 36262 # GL/glext.h:4559
# NV_geometry_program4 (GL/glext.h:4562)
GL_LINES_ADJACENCY_EXT = 10 # GL/glext.h:4563
GL_LINE_STRIP_ADJACENCY_EXT = 11 # GL/glext.h:4564
GL_TRIANGLES_ADJACENCY_EXT = 12 # GL/glext.h:4565
GL_TRIANGLE_STRIP_ADJACENCY_EXT = 13 # GL/glext.h:4566
GL_GEOMETRY_PROGRAM_NV = 35878 # GL/glext.h:4567
GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 35879 # GL/glext.h:4568
GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 35880 # GL/glext.h:4569
GL_GEOMETRY_VERTICES_OUT_EXT = 36314 # GL/glext.h:4570
GL_GEOMETRY_INPUT_TYPE_EXT = 36315 # GL/glext.h:4571
GL_GEOMETRY_OUTPUT_TYPE_EXT = 36316 # GL/glext.h:4572
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 35881 # GL/glext.h:4573
GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 36263 # GL/glext.h:4574
GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 36264 # GL/glext.h:4575
GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 36265 # GL/glext.h:4576
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 36052 # GL/glext.h:4577
GL_PROGRAM_POINT_SIZE_EXT = 34370 # GL/glext.h:4578
# EXT_geometry_shader4 (GL/glext.h:4581)
GL_GEOMETRY_SHADER_EXT = 36313 # GL/glext.h:4582
GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 36317 # GL/glext.h:4587
GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 36318 # GL/glext.h:4588
GL_MAX_VARYING_COMPONENTS_EXT = 35659 # GL/glext.h:4589
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 36319 # GL/glext.h:4590
GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 36320 # GL/glext.h:4591
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 36321 # GL/glext.h:4592
# NV_vertex_program4 (GL/glext.h:4604)
GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 35069 # GL/glext.h:4605
# EXT_gpu_shader4 (GL/glext.h:4608)
GL_SAMPLER_1D_ARRAY_EXT = 36288 # GL/glext.h:4609
GL_SAMPLER_2D_ARRAY_EXT = 36289 # GL/glext.h:4610
GL_SAMPLER_BUFFER_EXT = 36290 # GL/glext.h:4611
GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 36291 # GL/glext.h:4612
GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 36292 # GL/glext.h:4613
GL_SAMPLER_CUBE_SHADOW_EXT = 36293 # GL/glext.h:4614
GL_UNSIGNED_INT_VEC2_EXT = 36294 # GL/glext.h:4615
GL_UNSIGNED_INT_VEC3_EXT = 36295 # GL/glext.h:4616
GL_UNSIGNED_INT_VEC4_EXT = 36296 # GL/glext.h:4617
GL_INT_SAMPLER_1D_EXT = 36297 # GL/glext.h:4618
GL_INT_SAMPLER_2D_EXT = 36298 # GL/glext.h:4619
GL_INT_SAMPLER_3D_EXT = 36299 # GL/glext.h:4620
GL_INT_SAMPLER_CUBE_EXT = 36300 # GL/glext.h:4621
GL_INT_SAMPLER_2D_RECT_EXT = 36301 # GL/glext.h:4622
GL_INT_SAMPLER_1D_ARRAY_EXT = 36302 # GL/glext.h:4623
GL_INT_SAMPLER_2D_ARRAY_EXT = 36303 # GL/glext.h:4624
GL_INT_SAMPLER_BUFFER_EXT = 36304 # GL/glext.h:4625
GL_UNSIGNED_INT_SAMPLER_1D_EXT = 36305 # GL/glext.h:4626
GL_UNSIGNED_INT_SAMPLER_2D_EXT = 36306 # GL/glext.h:4627
GL_UNSIGNED_INT_SAMPLER_3D_EXT = 36307 # GL/glext.h:4628
GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 36308 # GL/glext.h:4629
GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 36309 # GL/glext.h:4630
GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 36310 # GL/glext.h:4631
GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 36311 # GL/glext.h:4632
GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 36312 # GL/glext.h:4633
# EXT_draw_instanced (GL/glext.h:4636)
# EXT_packed_float (GL/glext.h:4639)
GL_R11F_G11F_B10F_EXT = 35898 # GL/glext.h:4640
GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 35899 # GL/glext.h:4641
GL_RGBA_SIGNED_COMPONENTS_EXT = 35900 # GL/glext.h:4642
# EXT_texture_array (GL/glext.h:4645)
GL_TEXTURE_1D_ARRAY_EXT = 35864 # GL/glext.h:4646
GL_PROXY_TEXTURE_1D_ARRAY_EXT = 35865 # GL/glext.h:4647
GL_TEXTURE_2D_ARRAY_EXT = 35866 # GL/glext.h:4648
GL_PROXY_TEXTURE_2D_ARRAY_EXT = 35867 # GL/glext.h:4649
GL_TEXTURE_BINDING_1D_ARRAY_EXT = 35868 # GL/glext.h:4650
GL_TEXTURE_BINDING_2D_ARRAY_EXT = 35869 # GL/glext.h:4651
GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 35071 # GL/glext.h:4652
GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 34894 # GL/glext.h:4653
# EXT_texture_buffer_object (GL/glext.h:4657)
GL_TEXTURE_BUFFER_EXT = 35882 # GL/glext.h:4658
GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 35883 # GL/glext.h:4659
GL_TEXTURE_BINDING_BUFFER_EXT = 35884 # GL/glext.h:4660
GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 35885 # GL/glext.h:4661
GL_TEXTURE_BUFFER_FORMAT_EXT = 35886 # GL/glext.h:4662
# EXT_texture_compression_latc (GL/glext.h:4665)
GL_COMPRESSED_LUMINANCE_LATC1_EXT = 35952 # GL/glext.h:4666
GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 35953 # GL/glext.h:4667
GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 35954 # GL/glext.h:4668
GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 35955 # GL/glext.h:4669
# EXT_texture_compression_rgtc (GL/glext.h:4672)
GL_COMPRESSED_RED_RGTC1_EXT = 36283 # GL/glext.h:4673
GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 36284 # GL/glext.h:4674
GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 36285 # GL/glext.h:4675
GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 36286 # GL/glext.h:4676
# EXT_texture_shared_exponent (GL/glext.h:4679)
GL_RGB9_E5_EXT = 35901 # GL/glext.h:4680
GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 35902 # GL/glext.h:4681
GL_TEXTURE_SHARED_SIZE_EXT = 35903 # GL/glext.h:4682
# NV_depth_buffer_float (GL/glext.h:4685)
GL_DEPTH_COMPONENT32F_NV = 36267 # GL/glext.h:4686
GL_DEPTH32F_STENCIL8_NV = 36268 # GL/glext.h:4687
GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 36269 # GL/glext.h:4688
GL_DEPTH_BUFFER_FLOAT_MODE_NV = 36271 # GL/glext.h:4689
# NV_fragment_program4 (GL/glext.h:4692)
# NV_framebuffer_multisample_coverage (GL/glext.h:4695)
GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 36011 # GL/glext.h:4696
GL_RENDERBUFFER_COLOR_SAMPLES_NV = 36368 # GL/glext.h:4697
GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 36369 # GL/glext.h:4698
GL_MULTISAMPLE_COVERAGE_MODES_NV = 36370 # GL/glext.h:4699
# EXT_framebuffer_sRGB (GL/glext.h:4702)
GL_FRAMEBUFFER_SRGB_EXT = 36281 # GL/glext.h:4703
GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 36282 # GL/glext.h:4704
# NV_geometry_shader4 (GL/glext.h:4707)
# NV_parameter_buffer_object (GL/glext.h:4710)
GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 36256 # GL/glext.h:4711
GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 36257 # GL/glext.h:4712
GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 36258 # GL/glext.h:4713
GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 36259 # GL/glext.h:4714
GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 36260 # GL/glext.h:4715
# EXT_draw_buffers2 (GL/glext.h:4718)
# NV_transform_feedback (GL/glext.h:4721)
GL_BACK_PRIMARY_COLOR_NV = 35959 # GL/glext.h:4722
GL_BACK_SECONDARY_COLOR_NV = 35960 # GL/glext.h:4723
GL_TEXTURE_COORD_NV = 35961 # GL/glext.h:4724
GL_CLIP_DISTANCE_NV = 35962 # GL/glext.h:4725
GL_VERTEX_ID_NV = 35963 # GL/glext.h:4726
GL_PRIMITIVE_ID_NV = 35964 # GL/glext.h:4727
GL_GENERIC_ATTRIB_NV = 35965 # GL/glext.h:4728
GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 35966 # GL/glext.h:4729
GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 35967 # GL/glext.h:4730
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 35968 # GL/glext.h:4731
GL_ACTIVE_VARYINGS_NV = 35969 # GL/glext.h:4732
GL_ACTIVE_VARYING_MAX_LENGTH_NV = 35970 # GL/glext.h:4733
GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 35971 # GL/glext.h:4734
GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 35972 # GL/glext.h:4735
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 35973 # GL/glext.h:4736
GL_TRANSFORM_FEEDBACK_RECORD_NV = 35974 # GL/glext.h:4737
GL_PRIMITIVES_GENERATED_NV = 35975 # GL/glext.h:4738
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 35976 # GL/glext.h:4739
GL_RASTERIZER_DISCARD_NV = 35977 # GL/glext.h:4740
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 35978 # GL/glext.h:4741
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 35979 # GL/glext.h:4742
GL_INTERLEAVED_ATTRIBS_NV = 35980 # GL/glext.h:4743
GL_SEPARATE_ATTRIBS_NV = 35981 # GL/glext.h:4744
GL_TRANSFORM_FEEDBACK_BUFFER_NV = 35982 # GL/glext.h:4745
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 35983 # GL/glext.h:4746
GL_LAYER_NV = 36266 # GL/glext.h:4747
GL_NEXT_BUFFER_NV = -2 # GL/glext.h:4748
GL_SKIP_COMPONENTS4_NV = -3 # GL/glext.h:4749
GL_SKIP_COMPONENTS3_NV = -4 # GL/glext.h:4750
GL_SKIP_COMPONENTS2_NV = -5 # GL/glext.h:4751
GL_SKIP_COMPONENTS1_NV = -6 # GL/glext.h:4752
# EXT_bindable_uniform (GL/glext.h:4755)
GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 36322 # GL/glext.h:4756
GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 36323 # GL/glext.h:4757
GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 36324 # GL/glext.h:4758
GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 36333 # GL/glext.h:4759
GL_UNIFORM_BUFFER_EXT = 36334 # GL/glext.h:4760
GL_UNIFORM_BUFFER_BINDING_EXT = 36335 # GL/glext.h:4761
# EXT_texture_integer (GL/glext.h:4764)
GL_RGBA32UI_EXT = 36208 # GL/glext.h:4765
GL_RGB32UI_EXT = 36209 # GL/glext.h:4766
GL_ALPHA32UI_EXT = 36210 # GL/glext.h:4767
GL_INTENSITY32UI_EXT = 36211 # GL/glext.h:4768
GL_LUMINANCE32UI_EXT = 36212 # GL/glext.h:4769
GL_LUMINANCE_ALPHA32UI_EXT = 36213 # GL/glext.h:4770
GL_RGBA16UI_EXT = 36214 # GL/glext.h:4771
GL_RGB16UI_EXT = 36215 # GL/glext.h:4772
GL_ALPHA16UI_EXT = 36216 # GL/glext.h:4773
GL_INTENSITY16UI_EXT = 36217 # GL/glext.h:4774
GL_LUMINANCE16UI_EXT = 36218 # GL/glext.h:4775
GL_LUMINANCE_ALPHA16UI_EXT = 36219 # GL/glext.h:4776
GL_RGBA8UI_EXT = 36220 # GL/glext.h:4777
GL_RGB8UI_EXT = 36221 # GL/glext.h:4778
GL_ALPHA8UI_EXT = 36222 # GL/glext.h:4779
GL_INTENSITY8UI_EXT = 36223 # GL/glext.h:4780
GL_LUMINANCE8UI_EXT = 36224 # GL/glext.h:4781
GL_LUMINANCE_ALPHA8UI_EXT = 36225 # GL/glext.h:4782
GL_RGBA32I_EXT = 36226 # GL/glext.h:4783
GL_RGB32I_EXT = 36227 # GL/glext.h:4784
GL_ALPHA32I_EXT = 36228 # GL/glext.h:4785
GL_INTENSITY32I_EXT = 36229 # GL/glext.h:4786
GL_LUMINANCE32I_EXT = 36230 # GL/glext.h:4787
GL_LUMINANCE_ALPHA32I_EXT = 36231 # GL/glext.h:4788
GL_RGBA16I_EXT = 36232 # GL/glext.h:4789
GL_RGB16I_EXT = 36233 # GL/glext.h:4790
GL_ALPHA16I_EXT = 36234 # GL/glext.h:4791
GL_INTENSITY16I_EXT = 36235 # GL/glext.h:4792
GL_LUMINANCE16I_EXT = 36236 # GL/glext.h:4793
GL_LUMINANCE_ALPHA16I_EXT = 36237 # GL/glext.h:4794
GL_RGBA8I_EXT = 36238 # GL/glext.h:4795
GL_RGB8I_EXT = 36239 # GL/glext.h:4796
GL_ALPHA8I_EXT = 36240 # GL/glext.h:4797
GL_INTENSITY8I_EXT = 36241 # GL/glext.h:4798
GL_LUMINANCE8I_EXT = 36242 # GL/glext.h:4799
GL_LUMINANCE_ALPHA8I_EXT = 36243 # GL/glext.h:4800
GL_RED_INTEGER_EXT = 36244 # GL/glext.h:4801
GL_GREEN_INTEGER_EXT = 36245 # GL/glext.h:4802
GL_BLUE_INTEGER_EXT = 36246 # GL/glext.h:4803
GL_ALPHA_INTEGER_EXT = 36247 # GL/glext.h:4804
GL_RGB_INTEGER_EXT = 36248 # GL/glext.h:4805
GL_RGBA_INTEGER_EXT = 36249 # GL/glext.h:4806
GL_BGR_INTEGER_EXT = 36250 # GL/glext.h:4807
GL_BGRA_INTEGER_EXT = 36251 # GL/glext.h:4808
GL_LUMINANCE_INTEGER_EXT = 36252 # GL/glext.h:4809
GL_LUMINANCE_ALPHA_INTEGER_EXT = 36253 # GL/glext.h:4810
GL_RGBA_INTEGER_MODE_EXT = 36254 # GL/glext.h:4811
# GREMEDY_frame_terminator (GL/glext.h:4814)
# NV_conditional_render (GL/glext.h:4817)
GL_QUERY_WAIT_NV = 36371 # GL/glext.h:4818
GL_QUERY_NO_WAIT_NV = 36372 # GL/glext.h:4819
GL_QUERY_BY_REGION_WAIT_NV = 36373 # GL/glext.h:4820
GL_QUERY_BY_REGION_NO_WAIT_NV = 36374 # GL/glext.h:4821
# NV_present_video (GL/glext.h:4824)
GL_FRAME_NV = 36390 # GL/glext.h:4825
GL_FIELDS_NV = 36391 # GL/glext.h:4826
GL_CURRENT_TIME_NV = 36392 # GL/glext.h:4827
GL_NUM_FILL_STREAMS_NV = 36393 # GL/glext.h:4828
GL_PRESENT_TIME_NV = 36394 # GL/glext.h:4829
GL_PRESENT_DURATION_NV = 36395 # GL/glext.h:4830
# EXT_transform_feedback (GL/glext.h:4833)
GL_TRANSFORM_FEEDBACK_BUFFER_EXT = 35982 # GL/glext.h:4834
GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 35972 # GL/glext.h:4835
GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 35973 # GL/glext.h:4836
GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 35983 # GL/glext.h:4837
GL_INTERLEAVED_ATTRIBS_EXT = 35980 # GL/glext.h:4838
GL_SEPARATE_ATTRIBS_EXT = 35981 # GL/glext.h:4839
GL_PRIMITIVES_GENERATED_EXT = 35975 # GL/glext.h:4840
GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 35976 # GL/glext.h:4841
GL_RASTERIZER_DISCARD_EXT = 35977 # GL/glext.h:4842
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 35978 # GL/glext.h:4843
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 35979 # GL/glext.h:4844
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 35968 # GL/glext.h:4845
GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 35971 # GL/glext.h:4846
GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 35967 # GL/glext.h:4847
GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 35958 # GL/glext.h:4848
# EXT_direct_state_access (GL/glext.h:4851)
GL_PROGRAM_MATRIX_EXT = 36397 # GL/glext.h:4852
GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 36398 # GL/glext.h:4853
GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 36399 # GL/glext.h:4854
# EXT_vertex_array_bgra (GL/glext.h:4857)
# EXT_texture_swizzle (GL/glext.h:4861)
GL_TEXTURE_SWIZZLE_R_EXT = 36418 # GL/glext.h:4862
GL_TEXTURE_SWIZZLE_G_EXT = 36419 # GL/glext.h:4863
GL_TEXTURE_SWIZZLE_B_EXT = 36420 # GL/glext.h:4864
GL_TEXTURE_SWIZZLE_A_EXT = 36421 # GL/glext.h:4865
GL_TEXTURE_SWIZZLE_RGBA_EXT = 36422 # GL/glext.h:4866
# NV_explicit_multisample (GL/glext.h:4869)
GL_SAMPLE_POSITION_NV = 36432 # GL/glext.h:4870
GL_SAMPLE_MASK_NV = 36433 # GL/glext.h:4871
GL_SAMPLE_MASK_VALUE_NV = 36434 # GL/glext.h:4872
GL_TEXTURE_BINDING_RENDERBUFFER_NV = 36435 # GL/glext.h:4873
GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 36436 # GL/glext.h:4874
GL_TEXTURE_RENDERBUFFER_NV = 36437 # GL/glext.h:4875
GL_SAMPLER_RENDERBUFFER_NV = 36438 # GL/glext.h:4876
GL_INT_SAMPLER_RENDERBUFFER_NV = 36439 # GL/glext.h:4877
GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 36440 # GL/glext.h:4878
GL_MAX_SAMPLE_MASK_WORDS_NV = 36441 # GL/glext.h:4879
# NV_transform_feedback2 (GL/glext.h:4882)
GL_TRANSFORM_FEEDBACK_NV = 36386 # GL/glext.h:4883
GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 36387 # GL/glext.h:4884
GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 36388 # GL/glext.h:4885
GL_TRANSFORM_FEEDBACK_BINDING_NV = 36389 # GL/glext.h:4886
# ATI_meminfo (GL/glext.h:4889)
GL_VBO_FREE_MEMORY_ATI = 34811 # GL/glext.h:4890
GL_TEXTURE_FREE_MEMORY_ATI = 34812 # GL/glext.h:4891
GL_RENDERBUFFER_FREE_MEMORY_ATI = 34813 # GL/glext.h:4892
# AMD_performance_monitor (GL/glext.h:4895)
GL_COUNTER_TYPE_AMD = 35776 # GL/glext.h:4896
GL_COUNTER_RANGE_AMD = 35777 # GL/glext.h:4897
GL_UNSIGNED_INT64_AMD = 35778 # GL/glext.h:4898
GL_PERCENTAGE_AMD = 35779 # GL/glext.h:4899
GL_PERFMON_RESULT_AVAILABLE_AMD = 35780 # GL/glext.h:4900
GL_PERFMON_RESULT_SIZE_AMD = 35781 # GL/glext.h:4901
GL_PERFMON_RESULT_AMD = 35782 # GL/glext.h:4902
# AMD_texture_texture4 (GL/glext.h:4905)
# AMD_vertex_shader_tesselator (GL/glext.h:4908)
GL_SAMPLER_BUFFER_AMD = 36865 # GL/glext.h:4909
GL_INT_SAMPLER_BUFFER_AMD = 36866 # GL/glext.h:4910
GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 36867 # GL/glext.h:4911
GL_TESSELLATION_MODE_AMD = 36868 # GL/glext.h:4912
GL_TESSELLATION_FACTOR_AMD = 36869 # GL/glext.h:4913
GL_DISCRETE_AMD = 36870 # GL/glext.h:4914
GL_CONTINUOUS_AMD = 36871 # GL/glext.h:4915
# EXT_provoking_vertex (GL/glext.h:4918)
GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 36428 # GL/glext.h:4919
GL_FIRST_VERTEX_CONVENTION_EXT = 36429 # GL/glext.h:4920
GL_LAST_VERTEX_CONVENTION_EXT = 36430 # GL/glext.h:4921
GL_PROVOKING_VERTEX_EXT = 36431 # GL/glext.h:4922
# EXT_texture_snorm (GL/glext.h:4925)
GL_ALPHA_SNORM = 36880 # GL/glext.h:4926
GL_LUMINANCE_SNORM = 36881 # GL/glext.h:4927
GL_LUMINANCE_ALPHA_SNORM = 36882 # GL/glext.h:4928
GL_INTENSITY_SNORM = 36883 # GL/glext.h:4929
GL_ALPHA8_SNORM = 36884 # GL/glext.h:4930
GL_LUMINANCE8_SNORM = 36885 # GL/glext.h:4931
GL_LUMINANCE8_ALPHA8_SNORM = 36886 # GL/glext.h:4932
GL_INTENSITY8_SNORM = 36887 # GL/glext.h:4933
GL_ALPHA16_SNORM = 36888 # GL/glext.h:4934
GL_LUMINANCE16_SNORM = 36889 # GL/glext.h:4935
GL_LUMINANCE16_ALPHA16_SNORM = 36890 # GL/glext.h:4936
GL_INTENSITY16_SNORM = 36891 # GL/glext.h:4937
# AMD_draw_buffers_blend (GL/glext.h:4953)
# APPLE_texture_range (GL/glext.h:4956)
GL_TEXTURE_RANGE_LENGTH_APPLE = 34231 # GL/glext.h:4957
GL_TEXTURE_RANGE_POINTER_APPLE = 34232 # GL/glext.h:4958
GL_TEXTURE_STORAGE_HINT_APPLE = 34236 # GL/glext.h:4959
GL_STORAGE_PRIVATE_APPLE = 34237 # GL/glext.h:4960
# APPLE_float_pixels (GL/glext.h:4965)
GL_HALF_APPLE = 5131 # GL/glext.h:4966
GL_RGBA_FLOAT32_APPLE = 34836 # GL/glext.h:4967
GL_RGB_FLOAT32_APPLE = 34837 # GL/glext.h:4968
GL_ALPHA_FLOAT32_APPLE = 34838 # GL/glext.h:4969
GL_INTENSITY_FLOAT32_APPLE = 34839 # GL/glext.h:4970
GL_LUMINANCE_FLOAT32_APPLE = 34840 # GL/glext.h:4971
GL_LUMINANCE_ALPHA_FLOAT32_APPLE = 34841 # GL/glext.h:4972
GL_RGBA_FLOAT16_APPLE = 34842 # GL/glext.h:4973
GL_RGB_FLOAT16_APPLE = 34843 # GL/glext.h:4974
GL_ALPHA_FLOAT16_APPLE = 34844 # GL/glext.h:4975
GL_INTENSITY_FLOAT16_APPLE = 34845 # GL/glext.h:4976
GL_LUMINANCE_FLOAT16_APPLE = 34846 # GL/glext.h:4977
GL_LUMINANCE_ALPHA_FLOAT16_APPLE = 34847 # GL/glext.h:4978
GL_COLOR_FLOAT_APPLE = 35343 # GL/glext.h:4979
# APPLE_vertex_program_evaluators (GL/glext.h:4982)
GL_VERTEX_ATTRIB_MAP1_APPLE = 35328 # GL/glext.h:4983
GL_VERTEX_ATTRIB_MAP2_APPLE = 35329 # GL/glext.h:4984
GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = 35330 # GL/glext.h:4985
GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = 35331 # GL/glext.h:4986
GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = 35332 # GL/glext.h:4987
GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = 35333 # GL/glext.h:4988
GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = 35334 # GL/glext.h:4989
GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = 35335 # GL/glext.h:4990
GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = 35336 # GL/glext.h:4991
GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = 35337 # GL/glext.h:4992
# APPLE_aux_depth_stencil (GL/glext.h:4995)
GL_AUX_DEPTH_STENCIL_APPLE = 35348 # GL/glext.h:4996
# APPLE_object_purgeable (GL/glext.h:4999)
GL_BUFFER_OBJECT_APPLE = 34227 # GL/glext.h:5000
GL_RELEASED_APPLE = 35353 # GL/glext.h:5001
GL_VOLATILE_APPLE = 35354 # GL/glext.h:5002
GL_RETAINED_APPLE = 35355 # GL/glext.h:5003
GL_UNDEFINED_APPLE = 35356 # GL/glext.h:5004
GL_PURGEABLE_APPLE = 35357 # GL/glext.h:5005
# APPLE_row_bytes (GL/glext.h:5008)
GL_PACK_ROW_BYTES_APPLE = 35349 # GL/glext.h:5009
GL_UNPACK_ROW_BYTES_APPLE = 35350 # GL/glext.h:5010
# APPLE_rgb_422 (GL/glext.h:5013)
GL_RGB_422_APPLE = 35359 # GL/glext.h:5014
# NV_video_capture (GL/glext.h:5019)
GL_VIDEO_BUFFER_NV = 36896 # GL/glext.h:5020
GL_VIDEO_BUFFER_BINDING_NV = 36897 # GL/glext.h:5021
GL_FIELD_UPPER_NV = 36898 # GL/glext.h:5022
GL_FIELD_LOWER_NV = 36899 # GL/glext.h:5023
GL_NUM_VIDEO_CAPTURE_STREAMS_NV = 36900 # GL/glext.h:5024
GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 36901 # GL/glext.h:5025
GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 36902 # GL/glext.h:5026
GL_LAST_VIDEO_CAPTURE_STATUS_NV = 36903 # GL/glext.h:5027
GL_VIDEO_BUFFER_PITCH_NV = 36904 # GL/glext.h:5028
GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = 36905 # GL/glext.h:5029
GL_VIDEO_COLOR_CONVERSION_MAX_NV = 36906 # GL/glext.h:5030
GL_VIDEO_COLOR_CONVERSION_MIN_NV = 36907 # GL/glext.h:5031
GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = 36908 # GL/glext.h:5032
GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 36909 # GL/glext.h:5033
GL_PARTIAL_SUCCESS_NV = 36910 # GL/glext.h:5034
GL_SUCCESS_NV = 36911 # GL/glext.h:5035
GL_FAILURE_NV = 36912 # GL/glext.h:5036
GL_YCBYCR8_422_NV = 36913 # GL/glext.h:5037
GL_YCBAYCR8A_4224_NV = 36914 # GL/glext.h:5038
GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 36915 # GL/glext.h:5039
GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 36916 # GL/glext.h:5040
GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 36917 # GL/glext.h:5041
GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 36918 # GL/glext.h:5042
GL_Z4Y12Z4CB12Z4CR12_444_NV = 36919 # GL/glext.h:5043
GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = 36920 # GL/glext.h:5044
GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 36921 # GL/glext.h:5045
GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 36922 # GL/glext.h:5046
GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 36923 # GL/glext.h:5047
GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 36924 # GL/glext.h:5048
# NV_copy_image (GL/glext.h:5051)
# EXT_separate_shader_objects (GL/glext.h:5054)
GL_ACTIVE_PROGRAM_EXT = 35725 # GL/glext.h:5055
# NV_parameter_buffer_object2 (GL/glext.h:5058)
# NV_shader_buffer_load (GL/glext.h:5061)
GL_BUFFER_GPU_ADDRESS_NV = 36637 # GL/glext.h:5062
GL_GPU_ADDRESS_NV = 36660 # GL/glext.h:5063
GL_MAX_SHADER_BUFFER_ADDRESS_NV = 36661 # GL/glext.h:5064
# NV_vertex_buffer_unified_memory (GL/glext.h:5067)
GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 36638 # GL/glext.h:5068
GL_ELEMENT_ARRAY_UNIFIED_NV = 36639 # GL/glext.h:5069
GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 36640 # GL/glext.h:5070
GL_VERTEX_ARRAY_ADDRESS_NV = 36641 # GL/glext.h:5071
GL_NORMAL_ARRAY_ADDRESS_NV = 36642 # GL/glext.h:5072
GL_COLOR_ARRAY_ADDRESS_NV = 36643 # GL/glext.h:5073
GL_INDEX_ARRAY_ADDRESS_NV = 36644 # GL/glext.h:5074
GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 36645 # GL/glext.h:5075
GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 36646 # GL/glext.h:5076
GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 36647 # GL/glext.h:5077
GL_FOG_COORD_ARRAY_ADDRESS_NV = 36648 # GL/glext.h:5078
GL_ELEMENT_ARRAY_ADDRESS_NV = 36649 # GL/glext.h:5079
GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 36650 # GL/glext.h:5080
GL_VERTEX_ARRAY_LENGTH_NV = 36651 # GL/glext.h:5081
GL_NORMAL_ARRAY_LENGTH_NV = 36652 # GL/glext.h:5082
GL_COLOR_ARRAY_LENGTH_NV = 36653 # GL/glext.h:5083
GL_INDEX_ARRAY_LENGTH_NV = 36654 # GL/glext.h:5084
GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 36655 # GL/glext.h:5085
GL_EDGE_FLAG_ARRAY_LENGTH_NV = 36656 # GL/glext.h:5086
GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 36657 # GL/glext.h:5087
GL_FOG_COORD_ARRAY_LENGTH_NV = 36658 # GL/glext.h:5088
GL_ELEMENT_ARRAY_LENGTH_NV = 36659 # GL/glext.h:5089
GL_DRAW_INDIRECT_UNIFIED_NV = 36672 # GL/glext.h:5090
GL_DRAW_INDIRECT_ADDRESS_NV = 36673 # GL/glext.h:5091
GL_DRAW_INDIRECT_LENGTH_NV = 36674 # GL/glext.h:5092
# NV_texture_barrier (GL/glext.h:5095)
# AMD_shader_stencil_export (GL/glext.h:5098)
# AMD_seamless_cubemap_per_texture (GL/glext.h:5101)
# AMD_conservative_depth (GL/glext.h:5105)
# EXT_shader_image_load_store (GL/glext.h:5108)
GL_MAX_IMAGE_UNITS_EXT = 36664 # GL/glext.h:5109
GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 36665 # GL/glext.h:5110
GL_IMAGE_BINDING_NAME_EXT = 36666 # GL/glext.h:5111
GL_IMAGE_BINDING_LEVEL_EXT = 36667 # GL/glext.h:5112
GL_IMAGE_BINDING_LAYERED_EXT = 36668 # GL/glext.h:5113
GL_IMAGE_BINDING_LAYER_EXT = 36669 # GL/glext.h:5114
GL_IMAGE_BINDING_ACCESS_EXT = 36670 # GL/glext.h:5115
GL_IMAGE_1D_EXT = 36940 # GL/glext.h:5116
GL_IMAGE_2D_EXT = 36941 # GL/glext.h:5117
GL_IMAGE_3D_EXT = 36942 # GL/glext.h:5118
GL_IMAGE_2D_RECT_EXT = 36943 # GL/glext.h:5119
GL_IMAGE_CUBE_EXT = 36944 # GL/glext.h:5120
GL_IMAGE_BUFFER_EXT = 36945 # GL/glext.h:5121
GL_IMAGE_1D_ARRAY_EXT = 36946 # GL/glext.h:5122
GL_IMAGE_2D_ARRAY_EXT = 36947 # GL/glext.h:5123
GL_IMAGE_CUBE_MAP_ARRAY_EXT = 36948 # GL/glext.h:5124
GL_IMAGE_2D_MULTISAMPLE_EXT = 36949 # GL/glext.h:5125
GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 36950 # GL/glext.h:5126
GL_INT_IMAGE_1D_EXT = 36951 # GL/glext.h:5127
GL_INT_IMAGE_2D_EXT = 36952 # GL/glext.h:5128
GL_INT_IMAGE_3D_EXT = 36953 # GL/glext.h:5129
GL_INT_IMAGE_2D_RECT_EXT = 36954 # GL/glext.h:5130
GL_INT_IMAGE_CUBE_EXT = 36955 # GL/glext.h:5131
GL_INT_IMAGE_BUFFER_EXT = 36956 # GL/glext.h:5132
GL_INT_IMAGE_1D_ARRAY_EXT = 36957 # GL/glext.h:5133
GL_INT_IMAGE_2D_ARRAY_EXT = 36958 # GL/glext.h:5134
GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 36959 # GL/glext.h:5135
GL_INT_IMAGE_2D_MULTISAMPLE_EXT = 36960 # GL/glext.h:5136
GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 36961 # GL/glext.h:5137
GL_UNSIGNED_INT_IMAGE_1D_EXT = 36962 # GL/glext.h:5138
GL_UNSIGNED_INT_IMAGE_2D_EXT = 36963 # GL/glext.h:5139
GL_UNSIGNED_INT_IMAGE_3D_EXT = 36964 # GL/glext.h:5140
GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 36965 # GL/glext.h:5141
GL_UNSIGNED_INT_IMAGE_CUBE_EXT = 36966 # GL/glext.h:5142
GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = 36967 # GL/glext.h:5143
GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 36968 # GL/glext.h:5144
GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 36969 # GL/glext.h:5145
GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 36970 # GL/glext.h:5146
GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 36971 # GL/glext.h:5147
GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 36972 # GL/glext.h:5148
GL_MAX_IMAGE_SAMPLES_EXT = 36973 # GL/glext.h:5149
GL_IMAGE_BINDING_FORMAT_EXT = 36974 # GL/glext.h:5150
GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 1 # GL/glext.h:5151
GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = 2 # GL/glext.h:5152
GL_UNIFORM_BARRIER_BIT_EXT = 4 # GL/glext.h:5153
GL_TEXTURE_FETCH_BARRIER_BIT_EXT = 8 # GL/glext.h:5154
GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 32 # GL/glext.h:5155
GL_COMMAND_BARRIER_BIT_EXT = 64 # GL/glext.h:5156
GL_PIXEL_BUFFER_BARRIER_BIT_EXT = 128 # GL/glext.h:5157
GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = 256 # GL/glext.h:5158
GL_BUFFER_UPDATE_BARRIER_BIT_EXT = 512 # GL/glext.h:5159
GL_FRAMEBUFFER_BARRIER_BIT_EXT = 1024 # GL/glext.h:5160
GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 2048 # GL/glext.h:5161
GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = 4096 # GL/glext.h:5162
GL_ALL_BARRIER_BITS_EXT = 4294967295 # GL/glext.h:5163
# EXT_vertex_attrib_64bit (GL/glext.h:5166)
GL_DOUBLE_VEC2_EXT = 36860 # GL/glext.h:5168
GL_DOUBLE_VEC3_EXT = 36861 # GL/glext.h:5169
GL_DOUBLE_VEC4_EXT = 36862 # GL/glext.h:5170
GL_DOUBLE_MAT2_EXT = 36678 # GL/glext.h:5171
GL_DOUBLE_MAT3_EXT = 36679 # GL/glext.h:5172
GL_DOUBLE_MAT4_EXT = 36680 # GL/glext.h:5173
GL_DOUBLE_MAT2x3_EXT = 36681 # GL/glext.h:5174
GL_DOUBLE_MAT2x4_EXT = 36682 # GL/glext.h:5175
GL_DOUBLE_MAT3x2_EXT = 36683 # GL/glext.h:5176
GL_DOUBLE_MAT3x4_EXT = 36684 # GL/glext.h:5177
GL_DOUBLE_MAT4x2_EXT = 36685 # GL/glext.h:5178
GL_DOUBLE_MAT4x3_EXT = 36686 # GL/glext.h:5179
# NV_gpu_program5 (GL/glext.h:5182)
GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = 36442 # GL/glext.h:5183
GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = 36443 # GL/glext.h:5184
GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = 36444 # GL/glext.h:5185
GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = 36445 # GL/glext.h:5186
GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 36446 # GL/glext.h:5187
GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 36447 # GL/glext.h:5188
GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = 36676 # GL/glext.h:5189
GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = 36677 # GL/glext.h:5190
# NV_gpu_shader5 (GL/glext.h:5193)
GL_INT64_NV = 5134 # GL/glext.h:5194
GL_UNSIGNED_INT64_NV = 5135 # GL/glext.h:5195
GL_INT8_NV = 36832 # GL/glext.h:5196
GL_INT8_VEC2_NV = 36833 # GL/glext.h:5197
GL_INT8_VEC3_NV = 36834 # GL/glext.h:5198
GL_INT8_VEC4_NV = 36835 # GL/glext.h:5199
GL_INT16_NV = 36836 # GL/glext.h:5200
GL_INT16_VEC2_NV = 36837 # GL/glext.h:5201
GL_INT16_VEC3_NV = 36838 # GL/glext.h:5202
GL_INT16_VEC4_NV = 36839 # GL/glext.h:5203
GL_INT64_VEC2_NV = 36841 # GL/glext.h:5204
GL_INT64_VEC3_NV = 36842 # GL/glext.h:5205
GL_INT64_VEC4_NV = 36843 # GL/glext.h:5206
GL_UNSIGNED_INT8_NV = 36844 # GL/glext.h:5207
GL_UNSIGNED_INT8_VEC2_NV = 36845 # GL/glext.h:5208
GL_UNSIGNED_INT8_VEC3_NV = 36846 # GL/glext.h:5209
GL_UNSIGNED_INT8_VEC4_NV = 36847 # GL/glext.h:5210
GL_UNSIGNED_INT16_NV = 36848 # GL/glext.h:5211
GL_UNSIGNED_INT16_VEC2_NV = 36849 # GL/glext.h:5212
GL_UNSIGNED_INT16_VEC3_NV = 36850 # GL/glext.h:5213
GL_UNSIGNED_INT16_VEC4_NV = 36851 # GL/glext.h:5214
GL_UNSIGNED_INT64_VEC2_NV = 36853 # GL/glext.h:5215
GL_UNSIGNED_INT64_VEC3_NV = 36854 # GL/glext.h:5216
GL_UNSIGNED_INT64_VEC4_NV = 36855 # GL/glext.h:5217
GL_FLOAT16_NV = 36856 # GL/glext.h:5218
GL_FLOAT16_VEC2_NV = 36857 # GL/glext.h:5219
GL_FLOAT16_VEC3_NV = 36858 # GL/glext.h:5220
GL_FLOAT16_VEC4_NV = 36859 # GL/glext.h:5221
# NV_shader_buffer_store (GL/glext.h:5225)
GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 16 # GL/glext.h:5226
# NV_tessellation_program5 (GL/glext.h:5231)
GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = 34520 # GL/glext.h:5232
GL_TESS_CONTROL_PROGRAM_NV = 35102 # GL/glext.h:5233
GL_TESS_EVALUATION_PROGRAM_NV = 35103 # GL/glext.h:5234
GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = 35956 # GL/glext.h:5235
GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = 35957 # GL/glext.h:5236
# NV_vertex_attrib_integer_64bit (GL/glext.h:5239)
# NV_multisample_coverage (GL/glext.h:5244)
GL_COVERAGE_SAMPLES_NV = 32937 # GL/glext.h:5245
GL_COLOR_SAMPLES_NV = 36384 # GL/glext.h:5246
# AMD_name_gen_delete (GL/glext.h:5249)
GL_DATA_BUFFER_AMD = 37201 # GL/glext.h:5250
GL_PERFORMANCE_MONITOR_AMD = 37202 # GL/glext.h:5251
GL_QUERY_OBJECT_AMD = 37203 # GL/glext.h:5252
GL_VERTEX_ARRAY_OBJECT_AMD = 37204 # GL/glext.h:5253
GL_SAMPLER_OBJECT_AMD = 37205 # GL/glext.h:5254
# AMD_debug_output (GL/glext.h:5257)
GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = 37188 # GL/glext.h:5258
GL_DEBUG_LOGGED_MESSAGES_AMD = 37189 # GL/glext.h:5259
GL_DEBUG_SEVERITY_HIGH_AMD = 37190 # GL/glext.h:5260
GL_DEBUG_SEVERITY_MEDIUM_AMD = 37191 # GL/glext.h:5261
GL_DEBUG_SEVERITY_LOW_AMD = 37192 # GL/glext.h:5262
GL_DEBUG_CATEGORY_API_ERROR_AMD = 37193 # GL/glext.h:5263
GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 37194 # GL/glext.h:5264
GL_DEBUG_CATEGORY_DEPRECATION_AMD = 37195 # GL/glext.h:5265
GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 37196 # GL/glext.h:5266
GL_DEBUG_CATEGORY_PERFORMANCE_AMD = 37197 # GL/glext.h:5267
GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 37198 # GL/glext.h:5268
GL_DEBUG_CATEGORY_APPLICATION_AMD = 37199 # GL/glext.h:5269
GL_DEBUG_CATEGORY_OTHER_AMD = 37200 # GL/glext.h:5270
# NV_vdpau_interop (GL/glext.h:5273)
GL_SURFACE_STATE_NV = 34539 # GL/glext.h:5274
GL_SURFACE_REGISTERED_NV = 34557 # GL/glext.h:5275
GL_SURFACE_MAPPED_NV = 34560 # GL/glext.h:5276
GL_WRITE_DISCARD_NV = 35006 # GL/glext.h:5277
# AMD_transform_feedback3_lines_triangles (GL/glext.h:5280)
# AMD_depth_clamp_separate (GL/glext.h:5283)
GL_DEPTH_CLAMP_NEAR_AMD = 36894 # GL/glext.h:5284
GL_DEPTH_CLAMP_FAR_AMD = 36895 # GL/glext.h:5285
# EXT_texture_sRGB_decode (GL/glext.h:5288)
GL_TEXTURE_SRGB_DECODE_EXT = 35400 # GL/glext.h:5289
GL_DECODE_EXT = 35401 # GL/glext.h:5290
GL_SKIP_DECODE_EXT = 35402 # GL/glext.h:5291
# NV_texture_multisample (GL/glext.h:5294)
GL_TEXTURE_COVERAGE_SAMPLES_NV = 36933 # GL/glext.h:5295
GL_TEXTURE_COLOR_SAMPLES_NV = 36934 # GL/glext.h:5296
# AMD_blend_minmax_factor (GL/glext.h:5299)
GL_FACTOR_MIN_AMD = 36892 # GL/glext.h:5300
GL_FACTOR_MAX_AMD = 36893 # GL/glext.h:5301
# AMD_sample_positions (GL/glext.h:5304)
GL_SUBSAMPLE_DISTANCE_AMD = 34879 # GL/glext.h:5305
# EXT_x11_sync_object (GL/glext.h:5308)
GL_SYNC_X11_FENCE_EXT = 37089 # GL/glext.h:5309
# AMD_multi_draw_indirect (GL/glext.h:5312)
# EXT_framebuffer_multisample_blit_scaled (GL/glext.h:5315)
GL_SCALED_RESOLVE_FASTEST_EXT = 37050 # GL/glext.h:5316
GL_SCALED_RESOLVE_NICEST_EXT = 37051 # GL/glext.h:5317
# NV_path_rendering (GL/glext.h:5320)
GL_PATH_FORMAT_SVG_NV = 36976 # GL/glext.h:5321
GL_PATH_FORMAT_PS_NV = 36977 # GL/glext.h:5322
GL_STANDARD_FONT_NAME_NV = 36978 # GL/glext.h:5323
GL_SYSTEM_FONT_NAME_NV = 36979 # GL/glext.h:5324
GL_FILE_NAME_NV = 36980 # GL/glext.h:5325
GL_PATH_STROKE_WIDTH_NV = 36981 # GL/glext.h:5326
GL_PATH_END_CAPS_NV = 36982 # GL/glext.h:5327
GL_PATH_INITIAL_END_CAP_NV = 36983 # GL/glext.h:5328
GL_PATH_TERMINAL_END_CAP_NV = 36984 # GL/glext.h:5329
GL_PATH_JOIN_STYLE_NV = 36985 # GL/glext.h:5330
GL_PATH_MITER_LIMIT_NV = 36986 # GL/glext.h:5331
GL_PATH_DASH_CAPS_NV = 36987 # GL/glext.h:5332
GL_PATH_INITIAL_DASH_CAP_NV = 36988 # GL/glext.h:5333
GL_PATH_TERMINAL_DASH_CAP_NV = 36989 # GL/glext.h:5334
GL_PATH_DASH_OFFSET_NV = 36990 # GL/glext.h:5335
GL_PATH_CLIENT_LENGTH_NV = 36991 # GL/glext.h:5336
GL_PATH_FILL_MODE_NV = 36992 # GL/glext.h:5337
GL_PATH_FILL_MASK_NV = 36993 # GL/glext.h:5338
GL_PATH_FILL_COVER_MODE_NV = 36994 # GL/glext.h:5339
GL_PATH_STROKE_COVER_MODE_NV = 36995 # GL/glext.h:5340
GL_PATH_STROKE_MASK_NV = 36996 # GL/glext.h:5341
GL_PATH_SAMPLE_QUALITY_NV = 36997 # GL/glext.h:5342
GL_PATH_STROKE_BOUND_NV = 36998 # GL/glext.h:5343
GL_PATH_STROKE_OVERSAMPLE_COUNT_NV = 36999 # GL/glext.h:5344
GL_COUNT_UP_NV = 37000 # GL/glext.h:5345
GL_COUNT_DOWN_NV = 37001 # GL/glext.h:5346
GL_PATH_OBJECT_BOUNDING_BOX_NV = 37002 # GL/glext.h:5347
GL_CONVEX_HULL_NV = 37003 # GL/glext.h:5348
GL_MULTI_HULLS_NV = 37004 # GL/glext.h:5349
GL_BOUNDING_BOX_NV = 37005 # GL/glext.h:5350
GL_TRANSLATE_X_NV = 37006 # GL/glext.h:5351
GL_TRANSLATE_Y_NV = 37007 # GL/glext.h:5352
GL_TRANSLATE_2D_NV = 37008 # GL/glext.h:5353
GL_TRANSLATE_3D_NV = 37009 # GL/glext.h:5354
GL_AFFINE_2D_NV = 37010 # GL/glext.h:5355
GL_PROJECTIVE_2D_NV = 37011 # GL/glext.h:5356
GL_AFFINE_3D_NV = 37012 # GL/glext.h:5357
GL_PROJECTIVE_3D_NV = 37013 # GL/glext.h:5358
GL_TRANSPOSE_AFFINE_2D_NV = 37014 # GL/glext.h:5359
GL_TRANSPOSE_PROJECTIVE_2D_NV = 37015 # GL/glext.h:5360
GL_TRANSPOSE_AFFINE_3D_NV = 37016 # GL/glext.h:5361
GL_TRANSPOSE_PROJECTIVE_3D_NV = 37017 # GL/glext.h:5362
GL_UTF8_NV = 37018 # GL/glext.h:5363
GL_UTF16_NV = 37019 # GL/glext.h:5364
GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 37020 # GL/glext.h:5365
GL_PATH_COMMAND_COUNT_NV = 37021 # GL/glext.h:5366
GL_PATH_COORD_COUNT_NV = 37022 # GL/glext.h:5367
GL_PATH_DASH_ARRAY_COUNT_NV = 37023 # GL/glext.h:5368
GL_PATH_COMPUTED_LENGTH_NV = 37024 # GL/glext.h:5369
GL_PATH_FILL_BOUNDING_BOX_NV = 37025 # GL/glext.h:5370
GL_PATH_STROKE_BOUNDING_BOX_NV = 37026 # GL/glext.h:5371
GL_SQUARE_NV = 37027 # GL/glext.h:5372
GL_ROUND_NV = 37028 # GL/glext.h:5373
GL_TRIANGULAR_NV = 37029 # GL/glext.h:5374
GL_BEVEL_NV = 37030 # GL/glext.h:5375
GL_MITER_REVERT_NV = 37031 # GL/glext.h:5376
GL_MITER_TRUNCATE_NV = 37032 # GL/glext.h:5377
GL_SKIP_MISSING_GLYPH_NV = 37033 # GL/glext.h:5378
GL_USE_MISSING_GLYPH_NV = 37034 # GL/glext.h:5379
GL_PATH_ERROR_POSITION_NV = 37035 # GL/glext.h:5380
GL_PATH_FOG_GEN_MODE_NV = 37036 # GL/glext.h:5381
GL_ACCUM_ADJACENT_PAIRS_NV = 37037 # GL/glext.h:5382
GL_ADJACENT_PAIRS_NV = 37038 # GL/glext.h:5383
GL_FIRST_TO_REST_NV = 37039 # GL/glext.h:5384
GL_PATH_GEN_MODE_NV = 37040 # GL/glext.h:5385
GL_PATH_GEN_COEFF_NV = 37041 # GL/glext.h:5386
GL_PATH_GEN_COLOR_FORMAT_NV = 37042 # GL/glext.h:5387
GL_PATH_GEN_COMPONENTS_NV = 37043 # GL/glext.h:5388
GL_PATH_STENCIL_FUNC_NV = 37047 # GL/glext.h:5389
GL_PATH_STENCIL_REF_NV = 37048 # GL/glext.h:5390
GL_PATH_STENCIL_VALUE_MASK_NV = 37049 # GL/glext.h:5391
GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 37053 # GL/glext.h:5392
GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 37054 # GL/glext.h:5393
GL_PATH_COVER_DEPTH_FUNC_NV = 37055 # GL/glext.h:5394
GL_PATH_DASH_OFFSET_RESET_NV = 37044 # GL/glext.h:5395
GL_MOVE_TO_RESETS_NV = 37045 # GL/glext.h:5396
GL_MOVE_TO_CONTINUES_NV = 37046 # GL/glext.h:5397
GL_CLOSE_PATH_NV = 0 # GL/glext.h:5398
GL_MOVE_TO_NV = 2 # GL/glext.h:5399
GL_RELATIVE_MOVE_TO_NV = 3 # GL/glext.h:5400
GL_LINE_TO_NV = 4 # GL/glext.h:5401
GL_RELATIVE_LINE_TO_NV = 5 # GL/glext.h:5402
GL_HORIZONTAL_LINE_TO_NV = 6 # GL/glext.h:5403
GL_RELATIVE_HORIZONTAL_LINE_TO_NV = 7 # GL/glext.h:5404
GL_VERTICAL_LINE_TO_NV = 8 # GL/glext.h:5405
GL_RELATIVE_VERTICAL_LINE_TO_NV = 9 # GL/glext.h:5406
GL_QUADRATIC_CURVE_TO_NV = 10 # GL/glext.h:5407
GL_RELATIVE_QUADRATIC_CURVE_TO_NV = 11 # GL/glext.h:5408
GL_CUBIC_CURVE_TO_NV = 12 # GL/glext.h:5409
GL_RELATIVE_CUBIC_CURVE_TO_NV = 13 # GL/glext.h:5410
GL_SMOOTH_QUADRATIC_CURVE_TO_NV = 14 # GL/glext.h:5411
GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 15 # GL/glext.h:5412
GL_SMOOTH_CUBIC_CURVE_TO_NV = 16 # GL/glext.h:5413
GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 17 # GL/glext.h:5414
GL_SMALL_CCW_ARC_TO_NV = 18 # GL/glext.h:5415
GL_RELATIVE_SMALL_CCW_ARC_TO_NV = 19 # GL/glext.h:5416
GL_SMALL_CW_ARC_TO_NV = 20 # GL/glext.h:5417
GL_RELATIVE_SMALL_CW_ARC_TO_NV = 21 # GL/glext.h:5418
GL_LARGE_CCW_ARC_TO_NV = 22 # GL/glext.h:5419
GL_RELATIVE_LARGE_CCW_ARC_TO_NV = 23 # GL/glext.h:5420
GL_LARGE_CW_ARC_TO_NV = 24 # GL/glext.h:5421
GL_RELATIVE_LARGE_CW_ARC_TO_NV = 25 # GL/glext.h:5422
GL_RESTART_PATH_NV = 240 # GL/glext.h:5423
GL_DUP_FIRST_CUBIC_CURVE_TO_NV = 242 # GL/glext.h:5424
GL_DUP_LAST_CUBIC_CURVE_TO_NV = 244 # GL/glext.h:5425
GL_RECT_NV = 246 # GL/glext.h:5426
GL_CIRCULAR_CCW_ARC_TO_NV = 248 # GL/glext.h:5427
GL_CIRCULAR_CW_ARC_TO_NV = 250 # GL/glext.h:5428
GL_CIRCULAR_TANGENT_ARC_TO_NV = 252 # GL/glext.h:5429
GL_ARC_TO_NV = 254 # GL/glext.h:5430
GL_RELATIVE_ARC_TO_NV = 255 # GL/glext.h:5431
GL_BOLD_BIT_NV = 1 # GL/glext.h:5432
GL_ITALIC_BIT_NV = 2 # GL/glext.h:5433
GL_GLYPH_WIDTH_BIT_NV = 1 # GL/glext.h:5434
GL_GLYPH_HEIGHT_BIT_NV = 2 # GL/glext.h:5435
GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 4 # GL/glext.h:5436
GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 8 # GL/glext.h:5437
GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 16 # GL/glext.h:5438
GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = 32 # GL/glext.h:5439
GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 64 # GL/glext.h:5440
GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 128 # GL/glext.h:5441
GL_GLYPH_HAS_KERNING_NV = 256 # GL/glext.h:5442
GL_FONT_X_MIN_BOUNDS_NV = 65536 # GL/glext.h:5443
GL_FONT_Y_MIN_BOUNDS_NV = 131072 # GL/glext.h:5444
GL_FONT_X_MAX_BOUNDS_NV = 262144 # GL/glext.h:5445
GL_FONT_Y_MAX_BOUNDS_NV = 524288 # GL/glext.h:5446
GL_FONT_UNITS_PER_EM_NV = 1048576 # GL/glext.h:5447
GL_FONT_ASCENDER_NV = 2097152 # GL/glext.h:5448
GL_FONT_DESCENDER_NV = 4194304 # GL/glext.h:5449
GL_FONT_HEIGHT_NV = 8388608 # GL/glext.h:5450
GL_FONT_MAX_ADVANCE_WIDTH_NV = 16777216 # GL/glext.h:5451
GL_FONT_MAX_ADVANCE_HEIGHT_NV = 33554432 # GL/glext.h:5452
GL_FONT_UNDERLINE_POSITION_NV = 67108864 # GL/glext.h:5453
GL_FONT_UNDERLINE_THICKNESS_NV = 134217728 # GL/glext.h:5454
GL_FONT_HAS_KERNING_NV = 268435456 # GL/glext.h:5455
# AMD_pinned_memory (GL/glext.h:5458)
GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 37216 # GL/glext.h:5459
# AMD_stencil_operation_extended (GL/glext.h:5462)
GL_SET_AMD = 34634 # GL/glext.h:5463
GL_REPLACE_VALUE_AMD = 34635 # GL/glext.h:5464
GL_STENCIL_OP_VALUE_AMD = 34636 # GL/glext.h:5465
GL_STENCIL_BACK_OP_VALUE_AMD = 34637 # GL/glext.h:5466
# AMD_vertex_shader_viewport_index (GL/glext.h:5469)
# AMD_vertex_shader_layer (GL/glext.h:5472)
# NV_bindless_texture (GL/glext.h:5475)
# NV_shader_atomic_float (GL/glext.h:5478)
# AMD_query_buffer_object (GL/glext.h:5481)
GL_QUERY_BUFFER_AMD = 37266 # GL/glext.h:5482
GL_QUERY_BUFFER_BINDING_AMD = 37267 # GL/glext.h:5483
GL_QUERY_RESULT_NO_WAIT_AMD = 37268 # GL/glext.h:5484
# VERSION_2_0 (GL/glext.h:5491)
GLchar = c_char # GL/glext.h:5493
# VERSION_1_5 (GL/glext.h:5496)
GLintptr = c_ptrdiff_t # GL/glext.h:5498
GLsizeiptr = c_ptrdiff_t # GL/glext.h:5499
# ARB_vertex_buffer_object (GL/glext.h:5502)
GLintptrARB = c_ptrdiff_t # GL/glext.h:5504
GLsizeiptrARB = c_ptrdiff_t # GL/glext.h:5505
# ARB_shader_objects (GL/glext.h:5508)
GLcharARB = c_char # GL/glext.h:5510
GLhandleARB = c_uint # GL/glext.h:5511
# ARB_half_float_pixel (GL/glext.h:5515)
GLhalfARB = c_ushort # GL/glext.h:5516
# NV_half_float (GL/glext.h:5519)
GLhalfNV = c_ushort # GL/glext.h:5520
# EXT_timer_query (GL/glext.h:5561)
GLint64EXT = c_int64 # GL/glext.h:5562
GLuint64EXT = c_uint64 # GL/glext.h:5563
# ARB_sync (GL/glext.h:5566)
GLint64 = c_int64 # GL/glext.h:5567
GLuint64 = c_uint64 # GL/glext.h:5568
class struct___GLsync(Structure):
__slots__ = [
]
struct___GLsync._fields_ = [
('_opaque_struct', c_int)
]
class struct___GLsync(Structure):
__slots__ = [
]
struct___GLsync._fields_ = [
('_opaque_struct', c_int)
]
GLsync = POINTER(struct___GLsync) # GL/glext.h:5569
# ARB_cl_event (GL/glext.h:5572)
# ARB_debug_output (GL/glext.h:5578)
GLenum = c_uint # /usr/include/GL/gl.h:149
GLuint = c_uint # /usr/include/GL/gl.h:158
GLsizei = c_int # /usr/include/GL/gl.h:159
GLvoid = None # /usr/include/GL/gl.h:152
GLDEBUGPROCARB = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLenum, GLsizei, POINTER(GLchar), POINTER(GLvoid)) # GL/glext.h:5579
# AMD_debug_output (GL/glext.h:5582)
GLDEBUGPROCAMD = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLsizei, POINTER(GLchar), POINTER(GLvoid)) # GL/glext.h:5583
# NV_vdpau_interop (GL/glext.h:5586)
GLvdpauSurfaceNV = GLintptr # GL/glext.h:5587
# VERSION_1_2 (GL/glext.h:5590)
# VERSION_1_2_DEPRECATED (GL/glext.h:5608)
GL_VERSION_1_2_DEPRECATED = 1 # GL/glext.h:5609
# GL/glext.h:5611
glColorTable = _link_function('glColorTable', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
GLfloat = c_float # /usr/include/GL/gl.h:160
# GL/glext.h:5612
glColorTableParameterfv = _link_function('glColorTableParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
GLint = c_int # /usr/include/GL/gl.h:155
# GL/glext.h:5613
glColorTableParameteriv = _link_function('glColorTableParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5614
glCopyColorTable = _link_function('glCopyColorTable', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5615
glGetColorTable = _link_function('glGetColorTable', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5616
glGetColorTableParameterfv = _link_function('glGetColorTableParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5617
glGetColorTableParameteriv = _link_function('glGetColorTableParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5618
glColorSubTable = _link_function('glColorSubTable', None, [GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5619
glCopyColorSubTable = _link_function('glCopyColorSubTable', None, [GLenum, GLsizei, GLint, GLint, GLsizei], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5620
glConvolutionFilter1D = _link_function('glConvolutionFilter1D', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5621
glConvolutionFilter2D = _link_function('glConvolutionFilter2D', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5622
glConvolutionParameterf = _link_function('glConvolutionParameterf', None, [GLenum, GLenum, GLfloat], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5623
glConvolutionParameterfv = _link_function('glConvolutionParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5624
glConvolutionParameteri = _link_function('glConvolutionParameteri', None, [GLenum, GLenum, GLint], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5625
glConvolutionParameteriv = _link_function('glConvolutionParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5626
glCopyConvolutionFilter1D = _link_function('glCopyConvolutionFilter1D', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5627
glCopyConvolutionFilter2D = _link_function('glCopyConvolutionFilter2D', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLsizei], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5628
glGetConvolutionFilter = _link_function('glGetConvolutionFilter', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5629
glGetConvolutionParameterfv = _link_function('glGetConvolutionParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5630
glGetConvolutionParameteriv = _link_function('glGetConvolutionParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5631
glGetSeparableFilter = _link_function('glGetSeparableFilter', None, [GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5632
glSeparableFilter2D = _link_function('glSeparableFilter2D', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
GLboolean = c_ubyte # /usr/include/GL/gl.h:150
# GL/glext.h:5633
glGetHistogram = _link_function('glGetHistogram', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5634
glGetHistogramParameterfv = _link_function('glGetHistogramParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5635
glGetHistogramParameteriv = _link_function('glGetHistogramParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5636
glGetMinmax = _link_function('glGetMinmax', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5637
glGetMinmaxParameterfv = _link_function('glGetMinmaxParameterfv', None, [GLenum, GLenum, POINTER(GLfloat)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5638
glGetMinmaxParameteriv = _link_function('glGetMinmaxParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5639
glHistogram = _link_function('glHistogram', None, [GLenum, GLsizei, GLenum, GLboolean], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5640
glMinmax = _link_function('glMinmax', None, [GLenum, GLenum, GLboolean], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5641
glResetHistogram = _link_function('glResetHistogram', None, [GLenum], 'VERSION_1_2_DEPRECATED')
# GL/glext.h:5642
glResetMinmax = _link_function('glResetMinmax', None, [GLenum], 'VERSION_1_2_DEPRECATED')
PFNGLCOLORTABLEPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5644
PFNGLCOLORTABLEPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5645
PFNGLCOLORTABLEPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5646
PFNGLCOPYCOLORTABLEPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:5647
PFNGLGETCOLORTABLEPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5648
PFNGLGETCOLORTABLEPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5649
PFNGLGETCOLORTABLEPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5650
PFNGLCOLORSUBTABLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5651
PFNGLCOPYCOLORSUBTABLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLint, GLint, GLsizei) # GL/glext.h:5652
PFNGLCONVOLUTIONFILTER1DPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5653
PFNGLCONVOLUTIONFILTER2DPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5654
PFNGLCONVOLUTIONPARAMETERFPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:5655
PFNGLCONVOLUTIONPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5656
PFNGLCONVOLUTIONPARAMETERIPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:5657
PFNGLCONVOLUTIONPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5658
PFNGLCOPYCONVOLUTIONFILTER1DPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:5659
PFNGLCOPYCONVOLUTIONFILTER2DPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:5660
PFNGLGETCONVOLUTIONFILTERPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5661
PFNGLGETCONVOLUTIONPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5662
PFNGLGETCONVOLUTIONPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5663
PFNGLGETSEPARABLEFILTERPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:5664
PFNGLSEPARABLEFILTER2DPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:5665
PFNGLGETHISTOGRAMPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5666
PFNGLGETHISTOGRAMPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5667
PFNGLGETHISTOGRAMPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5668
PFNGLGETMINMAXPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:5669
PFNGLGETMINMAXPARAMETERFVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:5670
PFNGLGETMINMAXPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5671
PFNGLHISTOGRAMPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLboolean) # GL/glext.h:5672
PFNGLMINMAXPROC = CFUNCTYPE(None, GLenum, GLenum, GLboolean) # GL/glext.h:5673
PFNGLRESETHISTOGRAMPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5674
PFNGLRESETMINMAXPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5675
# VERSION_1_3 (GL/glext.h:5678)
# VERSION_1_3_DEPRECATED (GL/glext.h:5702)
GL_VERSION_1_3_DEPRECATED = 1 # GL/glext.h:5703
# GL/glext.h:5705
glClientActiveTexture = _link_function('glClientActiveTexture', None, [GLenum], 'VERSION_1_3_DEPRECATED')
GLdouble = c_double # /usr/include/GL/gl.h:162
# GL/glext.h:5706
glMultiTexCoord1d = _link_function('glMultiTexCoord1d', None, [GLenum, GLdouble], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5707
glMultiTexCoord1dv = _link_function('glMultiTexCoord1dv', None, [GLenum, POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5708
glMultiTexCoord1f = _link_function('glMultiTexCoord1f', None, [GLenum, GLfloat], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5709
glMultiTexCoord1fv = _link_function('glMultiTexCoord1fv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5710
glMultiTexCoord1i = _link_function('glMultiTexCoord1i', None, [GLenum, GLint], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5711
glMultiTexCoord1iv = _link_function('glMultiTexCoord1iv', None, [GLenum, POINTER(GLint)], 'VERSION_1_3_DEPRECATED')
GLshort = c_short # /usr/include/GL/gl.h:154
# GL/glext.h:5712
glMultiTexCoord1s = _link_function('glMultiTexCoord1s', None, [GLenum, GLshort], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5713
glMultiTexCoord1sv = _link_function('glMultiTexCoord1sv', None, [GLenum, POINTER(GLshort)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5714
glMultiTexCoord2d = _link_function('glMultiTexCoord2d', None, [GLenum, GLdouble, GLdouble], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5715
glMultiTexCoord2dv = _link_function('glMultiTexCoord2dv', None, [GLenum, POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5716
glMultiTexCoord2f = _link_function('glMultiTexCoord2f', None, [GLenum, GLfloat, GLfloat], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5717
glMultiTexCoord2fv = _link_function('glMultiTexCoord2fv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5718
glMultiTexCoord2i = _link_function('glMultiTexCoord2i', None, [GLenum, GLint, GLint], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5719
glMultiTexCoord2iv = _link_function('glMultiTexCoord2iv', None, [GLenum, POINTER(GLint)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5720
glMultiTexCoord2s = _link_function('glMultiTexCoord2s', None, [GLenum, GLshort, GLshort], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5721
glMultiTexCoord2sv = _link_function('glMultiTexCoord2sv', None, [GLenum, POINTER(GLshort)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5722
glMultiTexCoord3d = _link_function('glMultiTexCoord3d', None, [GLenum, GLdouble, GLdouble, GLdouble], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5723
glMultiTexCoord3dv = _link_function('glMultiTexCoord3dv', None, [GLenum, POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5724
glMultiTexCoord3f = _link_function('glMultiTexCoord3f', None, [GLenum, GLfloat, GLfloat, GLfloat], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5725
glMultiTexCoord3fv = _link_function('glMultiTexCoord3fv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5726
glMultiTexCoord3i = _link_function('glMultiTexCoord3i', None, [GLenum, GLint, GLint, GLint], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5727
glMultiTexCoord3iv = _link_function('glMultiTexCoord3iv', None, [GLenum, POINTER(GLint)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5728
glMultiTexCoord3s = _link_function('glMultiTexCoord3s', None, [GLenum, GLshort, GLshort, GLshort], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5729
glMultiTexCoord3sv = _link_function('glMultiTexCoord3sv', None, [GLenum, POINTER(GLshort)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5730
glMultiTexCoord4d = _link_function('glMultiTexCoord4d', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5731
glMultiTexCoord4dv = _link_function('glMultiTexCoord4dv', None, [GLenum, POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5732
glMultiTexCoord4f = _link_function('glMultiTexCoord4f', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5733
glMultiTexCoord4fv = _link_function('glMultiTexCoord4fv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5734
glMultiTexCoord4i = _link_function('glMultiTexCoord4i', None, [GLenum, GLint, GLint, GLint, GLint], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5735
glMultiTexCoord4iv = _link_function('glMultiTexCoord4iv', None, [GLenum, POINTER(GLint)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5736
glMultiTexCoord4s = _link_function('glMultiTexCoord4s', None, [GLenum, GLshort, GLshort, GLshort, GLshort], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5737
glMultiTexCoord4sv = _link_function('glMultiTexCoord4sv', None, [GLenum, POINTER(GLshort)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5738
glLoadTransposeMatrixf = _link_function('glLoadTransposeMatrixf', None, [POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5739
glLoadTransposeMatrixd = _link_function('glLoadTransposeMatrixd', None, [POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5740
glMultTransposeMatrixf = _link_function('glMultTransposeMatrixf', None, [POINTER(GLfloat)], 'VERSION_1_3_DEPRECATED')
# GL/glext.h:5741
glMultTransposeMatrixd = _link_function('glMultTransposeMatrixd', None, [POINTER(GLdouble)], 'VERSION_1_3_DEPRECATED')
PFNGLCLIENTACTIVETEXTUREPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5743
PFNGLMULTITEXCOORD1DPROC = CFUNCTYPE(None, GLenum, GLdouble) # GL/glext.h:5744
PFNGLMULTITEXCOORD1DVPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:5745
PFNGLMULTITEXCOORD1FPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5746
PFNGLMULTITEXCOORD1FVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5747
PFNGLMULTITEXCOORD1IPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5748
PFNGLMULTITEXCOORD1IVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5749
PFNGLMULTITEXCOORD1SPROC = CFUNCTYPE(None, GLenum, GLshort) # GL/glext.h:5750
PFNGLMULTITEXCOORD1SVPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:5751
PFNGLMULTITEXCOORD2DPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble) # GL/glext.h:5752
PFNGLMULTITEXCOORD2DVPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:5753
PFNGLMULTITEXCOORD2FPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat) # GL/glext.h:5754
PFNGLMULTITEXCOORD2FVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5755
PFNGLMULTITEXCOORD2IPROC = CFUNCTYPE(None, GLenum, GLint, GLint) # GL/glext.h:5756
PFNGLMULTITEXCOORD2IVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5757
PFNGLMULTITEXCOORD2SPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort) # GL/glext.h:5758
PFNGLMULTITEXCOORD2SVPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:5759
PFNGLMULTITEXCOORD3DPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:5760
PFNGLMULTITEXCOORD3DVPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:5761
PFNGLMULTITEXCOORD3FPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:5762
PFNGLMULTITEXCOORD3FVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5763
PFNGLMULTITEXCOORD3IPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # GL/glext.h:5764
PFNGLMULTITEXCOORD3IVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5765
PFNGLMULTITEXCOORD3SPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # GL/glext.h:5766
PFNGLMULTITEXCOORD3SVPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:5767
PFNGLMULTITEXCOORD4DPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:5768
PFNGLMULTITEXCOORD4DVPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:5769
PFNGLMULTITEXCOORD4FPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:5770
PFNGLMULTITEXCOORD4FVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5771
PFNGLMULTITEXCOORD4IPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint) # GL/glext.h:5772
PFNGLMULTITEXCOORD4IVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5773
PFNGLMULTITEXCOORD4SPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:5774
PFNGLMULTITEXCOORD4SVPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:5775
PFNGLLOADTRANSPOSEMATRIXFPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5776
PFNGLLOADTRANSPOSEMATRIXDPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5777
PFNGLMULTTRANSPOSEMATRIXFPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5778
PFNGLMULTTRANSPOSEMATRIXDPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5779
# VERSION_1_4 (GL/glext.h:5782)
GL_VERSION_1_4 = 1 # GL/glext.h:5783
# GL/glext.h:5785
glBlendFuncSeparate = _link_function('glBlendFuncSeparate', None, [GLenum, GLenum, GLenum, GLenum], 'VERSION_1_4')
# GL/glext.h:5786
glMultiDrawArrays = _link_function('glMultiDrawArrays', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'VERSION_1_4')
# GL/glext.h:5787
glMultiDrawElements = _link_function('glMultiDrawElements', None, [GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei], 'VERSION_1_4')
# GL/glext.h:5788
glPointParameterf = _link_function('glPointParameterf', None, [GLenum, GLfloat], 'VERSION_1_4')
# GL/glext.h:5789
glPointParameterfv = _link_function('glPointParameterfv', None, [GLenum, POINTER(GLfloat)], 'VERSION_1_4')
# GL/glext.h:5790
glPointParameteri = _link_function('glPointParameteri', None, [GLenum, GLint], 'VERSION_1_4')
# GL/glext.h:5791
glPointParameteriv = _link_function('glPointParameteriv', None, [GLenum, POINTER(GLint)], 'VERSION_1_4')
PFNGLBLENDFUNCSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:5793
PFNGLMULTIDRAWARRAYSPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:5794
PFNGLMULTIDRAWELEMENTSPROC = CFUNCTYPE(None, GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei) # GL/glext.h:5795
PFNGLPOINTPARAMETERFPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:5796
PFNGLPOINTPARAMETERFVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:5797
PFNGLPOINTPARAMETERIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:5798
PFNGLPOINTPARAMETERIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:5799
# VERSION_1_4_DEPRECATED (GL/glext.h:5802)
GL_VERSION_1_4_DEPRECATED = 1 # GL/glext.h:5803
# GL/glext.h:5805
glFogCoordf = _link_function('glFogCoordf', None, [GLfloat], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5806
glFogCoordfv = _link_function('glFogCoordfv', None, [POINTER(GLfloat)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5807
glFogCoordd = _link_function('glFogCoordd', None, [GLdouble], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5808
glFogCoorddv = _link_function('glFogCoorddv', None, [POINTER(GLdouble)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5809
glFogCoordPointer = _link_function('glFogCoordPointer', None, [GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_1_4_DEPRECATED')
GLbyte = c_char # /usr/include/GL/gl.h:153
# GL/glext.h:5810
glSecondaryColor3b = _link_function('glSecondaryColor3b', None, [GLbyte, GLbyte, GLbyte], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5811
glSecondaryColor3bv = _link_function('glSecondaryColor3bv', None, [POINTER(GLbyte)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5812
glSecondaryColor3d = _link_function('glSecondaryColor3d', None, [GLdouble, GLdouble, GLdouble], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5813
glSecondaryColor3dv = _link_function('glSecondaryColor3dv', None, [POINTER(GLdouble)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5814
glSecondaryColor3f = _link_function('glSecondaryColor3f', None, [GLfloat, GLfloat, GLfloat], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5815
glSecondaryColor3fv = _link_function('glSecondaryColor3fv', None, [POINTER(GLfloat)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5816
glSecondaryColor3i = _link_function('glSecondaryColor3i', None, [GLint, GLint, GLint], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5817
glSecondaryColor3iv = _link_function('glSecondaryColor3iv', None, [POINTER(GLint)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5818
glSecondaryColor3s = _link_function('glSecondaryColor3s', None, [GLshort, GLshort, GLshort], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5819
glSecondaryColor3sv = _link_function('glSecondaryColor3sv', None, [POINTER(GLshort)], 'VERSION_1_4_DEPRECATED')
GLubyte = c_ubyte # /usr/include/GL/gl.h:156
# GL/glext.h:5820
glSecondaryColor3ub = _link_function('glSecondaryColor3ub', None, [GLubyte, GLubyte, GLubyte], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5821
glSecondaryColor3ubv = _link_function('glSecondaryColor3ubv', None, [POINTER(GLubyte)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5822
glSecondaryColor3ui = _link_function('glSecondaryColor3ui', None, [GLuint, GLuint, GLuint], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5823
glSecondaryColor3uiv = _link_function('glSecondaryColor3uiv', None, [POINTER(GLuint)], 'VERSION_1_4_DEPRECATED')
GLushort = c_ushort # /usr/include/GL/gl.h:157
# GL/glext.h:5824
glSecondaryColor3us = _link_function('glSecondaryColor3us', None, [GLushort, GLushort, GLushort], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5825
glSecondaryColor3usv = _link_function('glSecondaryColor3usv', None, [POINTER(GLushort)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5826
glSecondaryColorPointer = _link_function('glSecondaryColorPointer', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5827
glWindowPos2d = _link_function('glWindowPos2d', None, [GLdouble, GLdouble], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5828
glWindowPos2dv = _link_function('glWindowPos2dv', None, [POINTER(GLdouble)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5829
glWindowPos2f = _link_function('glWindowPos2f', None, [GLfloat, GLfloat], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5830
glWindowPos2fv = _link_function('glWindowPos2fv', None, [POINTER(GLfloat)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5831
glWindowPos2i = _link_function('glWindowPos2i', None, [GLint, GLint], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5832
glWindowPos2iv = _link_function('glWindowPos2iv', None, [POINTER(GLint)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5833
glWindowPos2s = _link_function('glWindowPos2s', None, [GLshort, GLshort], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5834
glWindowPos2sv = _link_function('glWindowPos2sv', None, [POINTER(GLshort)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5835
glWindowPos3d = _link_function('glWindowPos3d', None, [GLdouble, GLdouble, GLdouble], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5836
glWindowPos3dv = _link_function('glWindowPos3dv', None, [POINTER(GLdouble)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5837
glWindowPos3f = _link_function('glWindowPos3f', None, [GLfloat, GLfloat, GLfloat], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5838
glWindowPos3fv = _link_function('glWindowPos3fv', None, [POINTER(GLfloat)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5839
glWindowPos3i = _link_function('glWindowPos3i', None, [GLint, GLint, GLint], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5840
glWindowPos3iv = _link_function('glWindowPos3iv', None, [POINTER(GLint)], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5841
glWindowPos3s = _link_function('glWindowPos3s', None, [GLshort, GLshort, GLshort], 'VERSION_1_4_DEPRECATED')
# GL/glext.h:5842
glWindowPos3sv = _link_function('glWindowPos3sv', None, [POINTER(GLshort)], 'VERSION_1_4_DEPRECATED')
PFNGLFOGCOORDFPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:5844
PFNGLFOGCOORDFVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5845
PFNGLFOGCOORDDPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:5846
PFNGLFOGCOORDDVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5847
PFNGLFOGCOORDPOINTERPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:5848
PFNGLSECONDARYCOLOR3BPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:5849
PFNGLSECONDARYCOLOR3BVPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:5850
PFNGLSECONDARYCOLOR3DPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:5851
PFNGLSECONDARYCOLOR3DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5852
PFNGLSECONDARYCOLOR3FPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:5853
PFNGLSECONDARYCOLOR3FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5854
PFNGLSECONDARYCOLOR3IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:5855
PFNGLSECONDARYCOLOR3IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:5856
PFNGLSECONDARYCOLOR3SPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:5857
PFNGLSECONDARYCOLOR3SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:5858
PFNGLSECONDARYCOLOR3UBPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte) # GL/glext.h:5859
PFNGLSECONDARYCOLOR3UBVPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:5860
PFNGLSECONDARYCOLOR3UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:5861
PFNGLSECONDARYCOLOR3UIVPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:5862
PFNGLSECONDARYCOLOR3USPROC = CFUNCTYPE(None, GLushort, GLushort, GLushort) # GL/glext.h:5863
PFNGLSECONDARYCOLOR3USVPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:5864
PFNGLSECONDARYCOLORPOINTERPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:5865
PFNGLWINDOWPOS2DPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:5866
PFNGLWINDOWPOS2DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5867
PFNGLWINDOWPOS2FPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:5868
PFNGLWINDOWPOS2FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5869
PFNGLWINDOWPOS2IPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:5870
PFNGLWINDOWPOS2IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:5871
PFNGLWINDOWPOS2SPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:5872
PFNGLWINDOWPOS2SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:5873
PFNGLWINDOWPOS3DPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:5874
PFNGLWINDOWPOS3DVPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:5875
PFNGLWINDOWPOS3FPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:5876
PFNGLWINDOWPOS3FVPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:5877
PFNGLWINDOWPOS3IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:5878
PFNGLWINDOWPOS3IVPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:5879
PFNGLWINDOWPOS3SPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:5880
PFNGLWINDOWPOS3SVPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:5881
# VERSION_1_5 (GL/glext.h:5884)
GL_VERSION_1_5 = 1 # GL/glext.h:5885
# GL/glext.h:5887
glGenQueries = _link_function('glGenQueries', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:5888
glDeleteQueries = _link_function('glDeleteQueries', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:5889
glIsQuery = _link_function('glIsQuery', GLboolean, [GLuint], 'VERSION_1_5')
# GL/glext.h:5890
glBeginQuery = _link_function('glBeginQuery', None, [GLenum, GLuint], 'VERSION_1_5')
# GL/glext.h:5891
glEndQuery = _link_function('glEndQuery', None, [GLenum], 'VERSION_1_5')
# GL/glext.h:5892
glGetQueryiv = _link_function('glGetQueryiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:5893
glGetQueryObjectiv = _link_function('glGetQueryObjectiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:5894
glGetQueryObjectuiv = _link_function('glGetQueryObjectuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:5895
glBindBuffer = _link_function('glBindBuffer', None, [GLenum, GLuint], 'VERSION_1_5')
# GL/glext.h:5896
glDeleteBuffers = _link_function('glDeleteBuffers', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:5897
glGenBuffers = _link_function('glGenBuffers', None, [GLsizei, POINTER(GLuint)], 'VERSION_1_5')
# GL/glext.h:5898
glIsBuffer = _link_function('glIsBuffer', GLboolean, [GLuint], 'VERSION_1_5')
# GL/glext.h:5899
glBufferData = _link_function('glBufferData', None, [GLenum, GLsizeiptr, POINTER(GLvoid), GLenum], 'VERSION_1_5')
# GL/glext.h:5900
glBufferSubData = _link_function('glBufferSubData', None, [GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'VERSION_1_5')
# GL/glext.h:5901
glGetBufferSubData = _link_function('glGetBufferSubData', None, [GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'VERSION_1_5')
# GL/glext.h:5902
glMapBuffer = _link_function('glMapBuffer', POINTER(GLvoid), [GLenum, GLenum], 'VERSION_1_5')
# GL/glext.h:5903
glUnmapBuffer = _link_function('glUnmapBuffer', GLboolean, [GLenum], 'VERSION_1_5')
# GL/glext.h:5904
glGetBufferParameteriv = _link_function('glGetBufferParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_1_5')
# GL/glext.h:5905
glGetBufferPointerv = _link_function('glGetBufferPointerv', None, [GLenum, GLenum, POINTER(POINTER(GLvoid))], 'VERSION_1_5')
PFNGLGENQUERIESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5907
PFNGLDELETEQUERIESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5908
PFNGLISQUERYPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5909
PFNGLBEGINQUERYPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:5910
PFNGLENDQUERYPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:5911
PFNGLGETQUERYIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5912
PFNGLGETQUERYOBJECTIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:5913
PFNGLGETQUERYOBJECTUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:5914
PFNGLBINDBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:5915
PFNGLDELETEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5916
PFNGLGENBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:5917
PFNGLISBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:5918
PFNGLBUFFERDATAPROC = CFUNCTYPE(None, GLenum, GLsizeiptr, POINTER(GLvoid), GLenum) # GL/glext.h:5919
PFNGLBUFFERSUBDATAPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:5920
PFNGLGETBUFFERSUBDATAPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:5921
PFNGLMAPBUFFERPROC = CFUNCTYPE(POINTER(GLvoid), GLenum, GLenum) # GL/glext.h:5922
PFNGLUNMAPBUFFERPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:5923
PFNGLGETBUFFERPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:5924
PFNGLGETBUFFERPOINTERVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:5925
# VERSION_2_0 (GL/glext.h:5928)
GL_VERSION_2_0 = 1 # GL/glext.h:5929
# GL/glext.h:5931
glBlendEquationSeparate = _link_function('glBlendEquationSeparate', None, [GLenum, GLenum], 'VERSION_2_0')
# GL/glext.h:5932
glDrawBuffers = _link_function('glDrawBuffers', None, [GLsizei, POINTER(GLenum)], 'VERSION_2_0')
# GL/glext.h:5933
glStencilOpSeparate = _link_function('glStencilOpSeparate', None, [GLenum, GLenum, GLenum, GLenum], 'VERSION_2_0')
# GL/glext.h:5934
glStencilFuncSeparate = _link_function('glStencilFuncSeparate', None, [GLenum, GLenum, GLint, GLuint], 'VERSION_2_0')
# GL/glext.h:5935
glStencilMaskSeparate = _link_function('glStencilMaskSeparate', None, [GLenum, GLuint], 'VERSION_2_0')
# GL/glext.h:5936
glAttachShader = _link_function('glAttachShader', None, [GLuint, GLuint], 'VERSION_2_0')
# GL/glext.h:5937
glBindAttribLocation = _link_function('glBindAttribLocation', None, [GLuint, GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5938
glCompileShader = _link_function('glCompileShader', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5939
glCreateProgram = _link_function('glCreateProgram', GLuint, [], 'VERSION_2_0')
# GL/glext.h:5940
glCreateShader = _link_function('glCreateShader', GLuint, [GLenum], 'VERSION_2_0')
# GL/glext.h:5941
glDeleteProgram = _link_function('glDeleteProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5942
glDeleteShader = _link_function('glDeleteShader', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5943
glDetachShader = _link_function('glDetachShader', None, [GLuint, GLuint], 'VERSION_2_0')
# GL/glext.h:5944
glDisableVertexAttribArray = _link_function('glDisableVertexAttribArray', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5945
glEnableVertexAttribArray = _link_function('glEnableVertexAttribArray', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5946
glGetActiveAttrib = _link_function('glGetActiveAttrib', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5947
glGetActiveUniform = _link_function('glGetActiveUniform', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5948
glGetAttachedShaders = _link_function('glGetAttachedShaders', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:5949
glGetAttribLocation = _link_function('glGetAttribLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5950
glGetProgramiv = _link_function('glGetProgramiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5951
glGetProgramInfoLog = _link_function('glGetProgramInfoLog', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5952
glGetShaderiv = _link_function('glGetShaderiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5953
glGetShaderInfoLog = _link_function('glGetShaderInfoLog', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5954
glGetShaderSource = _link_function('glGetShaderSource', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5955
glGetUniformLocation = _link_function('glGetUniformLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_2_0')
# GL/glext.h:5956
glGetUniformfv = _link_function('glGetUniformfv', None, [GLuint, GLint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5957
glGetUniformiv = _link_function('glGetUniformiv', None, [GLuint, GLint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5958
glGetVertexAttribdv = _link_function('glGetVertexAttribdv', None, [GLuint, GLenum, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:5959
glGetVertexAttribfv = _link_function('glGetVertexAttribfv', None, [GLuint, GLenum, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5960
glGetVertexAttribiv = _link_function('glGetVertexAttribiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5961
glGetVertexAttribPointerv = _link_function('glGetVertexAttribPointerv', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'VERSION_2_0')
# GL/glext.h:5962
glIsProgram = _link_function('glIsProgram', GLboolean, [GLuint], 'VERSION_2_0')
# GL/glext.h:5963
glIsShader = _link_function('glIsShader', GLboolean, [GLuint], 'VERSION_2_0')
# GL/glext.h:5964
glLinkProgram = _link_function('glLinkProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5965
glShaderSource = _link_function('glShaderSource', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5966
glUseProgram = _link_function('glUseProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5967
glUniform1f = _link_function('glUniform1f', None, [GLint, GLfloat], 'VERSION_2_0')
# GL/glext.h:5968
glUniform2f = _link_function('glUniform2f', None, [GLint, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:5969
glUniform3f = _link_function('glUniform3f', None, [GLint, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:5970
glUniform4f = _link_function('glUniform4f', None, [GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:5971
glUniform1i = _link_function('glUniform1i', None, [GLint, GLint], 'VERSION_2_0')
# GL/glext.h:5972
glUniform2i = _link_function('glUniform2i', None, [GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:5973
glUniform3i = _link_function('glUniform3i', None, [GLint, GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:5974
glUniform4i = _link_function('glUniform4i', None, [GLint, GLint, GLint, GLint, GLint], 'VERSION_2_0')
# GL/glext.h:5975
glUniform1fv = _link_function('glUniform1fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5976
glUniform2fv = _link_function('glUniform2fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5977
glUniform3fv = _link_function('glUniform3fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5978
glUniform4fv = _link_function('glUniform4fv', None, [GLint, GLsizei, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5979
glUniform1iv = _link_function('glUniform1iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5980
glUniform2iv = _link_function('glUniform2iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5981
glUniform3iv = _link_function('glUniform3iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5982
glUniform4iv = _link_function('glUniform4iv', None, [GLint, GLsizei, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:5983
glUniformMatrix2fv = _link_function('glUniformMatrix2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5984
glUniformMatrix3fv = _link_function('glUniformMatrix3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5985
glUniformMatrix4fv = _link_function('glUniformMatrix4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5986
glValidateProgram = _link_function('glValidateProgram', None, [GLuint], 'VERSION_2_0')
# GL/glext.h:5987
glVertexAttrib1d = _link_function('glVertexAttrib1d', None, [GLuint, GLdouble], 'VERSION_2_0')
# GL/glext.h:5988
glVertexAttrib1dv = _link_function('glVertexAttrib1dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:5989
glVertexAttrib1f = _link_function('glVertexAttrib1f', None, [GLuint, GLfloat], 'VERSION_2_0')
# GL/glext.h:5990
glVertexAttrib1fv = _link_function('glVertexAttrib1fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5991
glVertexAttrib1s = _link_function('glVertexAttrib1s', None, [GLuint, GLshort], 'VERSION_2_0')
# GL/glext.h:5992
glVertexAttrib1sv = _link_function('glVertexAttrib1sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:5993
glVertexAttrib2d = _link_function('glVertexAttrib2d', None, [GLuint, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:5994
glVertexAttrib2dv = _link_function('glVertexAttrib2dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:5995
glVertexAttrib2f = _link_function('glVertexAttrib2f', None, [GLuint, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:5996
glVertexAttrib2fv = _link_function('glVertexAttrib2fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:5997
glVertexAttrib2s = _link_function('glVertexAttrib2s', None, [GLuint, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:5998
glVertexAttrib2sv = _link_function('glVertexAttrib2sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:5999
glVertexAttrib3d = _link_function('glVertexAttrib3d', None, [GLuint, GLdouble, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:6000
glVertexAttrib3dv = _link_function('glVertexAttrib3dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:6001
glVertexAttrib3f = _link_function('glVertexAttrib3f', None, [GLuint, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:6002
glVertexAttrib3fv = _link_function('glVertexAttrib3fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:6003
glVertexAttrib3s = _link_function('glVertexAttrib3s', None, [GLuint, GLshort, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:6004
glVertexAttrib3sv = _link_function('glVertexAttrib3sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:6005
glVertexAttrib4Nbv = _link_function('glVertexAttrib4Nbv', None, [GLuint, POINTER(GLbyte)], 'VERSION_2_0')
# GL/glext.h:6006
glVertexAttrib4Niv = _link_function('glVertexAttrib4Niv', None, [GLuint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:6007
glVertexAttrib4Nsv = _link_function('glVertexAttrib4Nsv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:6008
glVertexAttrib4Nub = _link_function('glVertexAttrib4Nub', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'VERSION_2_0')
# GL/glext.h:6009
glVertexAttrib4Nubv = _link_function('glVertexAttrib4Nubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_2_0')
# GL/glext.h:6010
glVertexAttrib4Nuiv = _link_function('glVertexAttrib4Nuiv', None, [GLuint, POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:6011
glVertexAttrib4Nusv = _link_function('glVertexAttrib4Nusv', None, [GLuint, POINTER(GLushort)], 'VERSION_2_0')
# GL/glext.h:6012
glVertexAttrib4bv = _link_function('glVertexAttrib4bv', None, [GLuint, POINTER(GLbyte)], 'VERSION_2_0')
# GL/glext.h:6013
glVertexAttrib4d = _link_function('glVertexAttrib4d', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'VERSION_2_0')
# GL/glext.h:6014
glVertexAttrib4dv = _link_function('glVertexAttrib4dv', None, [GLuint, POINTER(GLdouble)], 'VERSION_2_0')
# GL/glext.h:6015
glVertexAttrib4f = _link_function('glVertexAttrib4f', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'VERSION_2_0')
# GL/glext.h:6016
glVertexAttrib4fv = _link_function('glVertexAttrib4fv', None, [GLuint, POINTER(GLfloat)], 'VERSION_2_0')
# GL/glext.h:6017
glVertexAttrib4iv = _link_function('glVertexAttrib4iv', None, [GLuint, POINTER(GLint)], 'VERSION_2_0')
# GL/glext.h:6018
glVertexAttrib4s = _link_function('glVertexAttrib4s', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'VERSION_2_0')
# GL/glext.h:6019
glVertexAttrib4sv = _link_function('glVertexAttrib4sv', None, [GLuint, POINTER(GLshort)], 'VERSION_2_0')
# GL/glext.h:6020
glVertexAttrib4ubv = _link_function('glVertexAttrib4ubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_2_0')
# GL/glext.h:6021
glVertexAttrib4uiv = _link_function('glVertexAttrib4uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_2_0')
# GL/glext.h:6022
glVertexAttrib4usv = _link_function('glVertexAttrib4usv', None, [GLuint, POINTER(GLushort)], 'VERSION_2_0')
# GL/glext.h:6023
glVertexAttribPointer = _link_function('glVertexAttribPointer', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)], 'VERSION_2_0')
PFNGLBLENDEQUATIONSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:6025
PFNGLDRAWBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:6026
PFNGLSTENCILOPSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6027
PFNGLSTENCILFUNCSEPARATEPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLuint) # GL/glext.h:6028
PFNGLSTENCILMASKSEPARATEPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6029
PFNGLATTACHSHADERPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:6030
PFNGLBINDATTRIBLOCATIONPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:6031
PFNGLCOMPILESHADERPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6032
PFNGLCREATEPROGRAMPROC = CFUNCTYPE(GLuint) # GL/glext.h:6033
PFNGLCREATESHADERPROC = CFUNCTYPE(GLuint, GLenum) # GL/glext.h:6034
PFNGLDELETEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6035
PFNGLDELETESHADERPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6036
PFNGLDETACHSHADERPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:6037
PFNGLDISABLEVERTEXATTRIBARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6038
PFNGLENABLEVERTEXATTRIBARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6039
PFNGLGETACTIVEATTRIBPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:6040
PFNGLGETACTIVEUNIFORMPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:6041
PFNGLGETATTACHEDSHADERSPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLuint)) # GL/glext.h:6042
PFNGLGETATTRIBLOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:6043
PFNGLGETPROGRAMIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6044
PFNGLGETPROGRAMINFOLOGPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:6045
PFNGLGETSHADERIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6046
PFNGLGETSHADERINFOLOGPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:6047
PFNGLGETSHADERSOURCEPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:6048
PFNGLGETUNIFORMLOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:6049
PFNGLGETUNIFORMFVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLfloat)) # GL/glext.h:6050
PFNGLGETUNIFORMIVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLint)) # GL/glext.h:6051
PFNGLGETVERTEXATTRIBDVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:6052
PFNGLGETVERTEXATTRIBFVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6053
PFNGLGETVERTEXATTRIBIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6054
PFNGLGETVERTEXATTRIBPOINTERVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:6055
PFNGLISPROGRAMPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6056
PFNGLISSHADERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6057
PFNGLLINKPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6058
PFNGLSHADERSOURCEPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)) # GL/glext.h:6059
PFNGLUSEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6060
PFNGLUNIFORM1FPROC = CFUNCTYPE(None, GLint, GLfloat) # GL/glext.h:6061
PFNGLUNIFORM2FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat) # GL/glext.h:6062
PFNGLUNIFORM3FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6063
PFNGLUNIFORM4FPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6064
PFNGLUNIFORM1IPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:6065
PFNGLUNIFORM2IPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6066
PFNGLUNIFORM3IPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:6067
PFNGLUNIFORM4IPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:6068
PFNGLUNIFORM1FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6069
PFNGLUNIFORM2FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6070
PFNGLUNIFORM3FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6071
PFNGLUNIFORM4FVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6072
PFNGLUNIFORM1IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6073
PFNGLUNIFORM2IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6074
PFNGLUNIFORM3IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6075
PFNGLUNIFORM4IVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6076
PFNGLUNIFORMMATRIX2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6077
PFNGLUNIFORMMATRIX3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6078
PFNGLUNIFORMMATRIX4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6079
PFNGLVALIDATEPROGRAMPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6080
PFNGLVERTEXATTRIB1DPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:6081
PFNGLVERTEXATTRIB1DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6082
PFNGLVERTEXATTRIB1FPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:6083
PFNGLVERTEXATTRIB1FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6084
PFNGLVERTEXATTRIB1SPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:6085
PFNGLVERTEXATTRIB1SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6086
PFNGLVERTEXATTRIB2DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:6087
PFNGLVERTEXATTRIB2DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6088
PFNGLVERTEXATTRIB2FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:6089
PFNGLVERTEXATTRIB2FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6090
PFNGLVERTEXATTRIB2SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:6091
PFNGLVERTEXATTRIB2SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6092
PFNGLVERTEXATTRIB3DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:6093
PFNGLVERTEXATTRIB3DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6094
PFNGLVERTEXATTRIB3FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6095
PFNGLVERTEXATTRIB3FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6096
PFNGLVERTEXATTRIB3SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:6097
PFNGLVERTEXATTRIB3SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6098
PFNGLVERTEXATTRIB4NBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:6099
PFNGLVERTEXATTRIB4NIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6100
PFNGLVERTEXATTRIB4NSVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6101
PFNGLVERTEXATTRIB4NUBPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:6102
PFNGLVERTEXATTRIB4NUBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6103
PFNGLVERTEXATTRIB4NUIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6104
PFNGLVERTEXATTRIB4NUSVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:6105
PFNGLVERTEXATTRIB4BVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:6106
PFNGLVERTEXATTRIB4DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6107
PFNGLVERTEXATTRIB4DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6108
PFNGLVERTEXATTRIB4FPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6109
PFNGLVERTEXATTRIB4FVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6110
PFNGLVERTEXATTRIB4IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6111
PFNGLVERTEXATTRIB4SPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:6112
PFNGLVERTEXATTRIB4SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6113
PFNGLVERTEXATTRIB4UBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6114
PFNGLVERTEXATTRIB4UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6115
PFNGLVERTEXATTRIB4USVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:6116
PFNGLVERTEXATTRIBPOINTERPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)) # GL/glext.h:6117
# VERSION_2_1 (GL/glext.h:6120)
GL_VERSION_2_1 = 1 # GL/glext.h:6121
# GL/glext.h:6123
glUniformMatrix2x3fv = _link_function('glUniformMatrix2x3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:6124
glUniformMatrix3x2fv = _link_function('glUniformMatrix3x2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:6125
glUniformMatrix2x4fv = _link_function('glUniformMatrix2x4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:6126
glUniformMatrix4x2fv = _link_function('glUniformMatrix4x2fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:6127
glUniformMatrix3x4fv = _link_function('glUniformMatrix3x4fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
# GL/glext.h:6128
glUniformMatrix4x3fv = _link_function('glUniformMatrix4x3fv', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'VERSION_2_1')
PFNGLUNIFORMMATRIX2X3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6130
PFNGLUNIFORMMATRIX3X2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6131
PFNGLUNIFORMMATRIX2X4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6132
PFNGLUNIFORMMATRIX4X2FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6133
PFNGLUNIFORMMATRIX3X4FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6134
PFNGLUNIFORMMATRIX4X3FVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6135
# VERSION_3_0 (GL/glext.h:6138)
GL_VERSION_3_0 = 1 # GL/glext.h:6139
# GL/glext.h:6145
glColorMaski = _link_function('glColorMaski', None, [GLuint, GLboolean, GLboolean, GLboolean, GLboolean], 'VERSION_3_0')
# GL/glext.h:6146
glGetBooleani_v = _link_function('glGetBooleani_v', None, [GLenum, GLuint, POINTER(GLboolean)], 'VERSION_3_0')
# GL/glext.h:6147
glGetIntegeri_v = _link_function('glGetIntegeri_v', None, [GLenum, GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6148
glEnablei = _link_function('glEnablei', None, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:6149
glDisablei = _link_function('glDisablei', None, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:6150
glIsEnabledi = _link_function('glIsEnabledi', GLboolean, [GLenum, GLuint], 'VERSION_3_0')
# GL/glext.h:6151
glBeginTransformFeedback = _link_function('glBeginTransformFeedback', None, [GLenum], 'VERSION_3_0')
# GL/glext.h:6152
glEndTransformFeedback = _link_function('glEndTransformFeedback', None, [], 'VERSION_3_0')
# GL/glext.h:6153
glBindBufferRange = _link_function('glBindBufferRange', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'VERSION_3_0')
# GL/glext.h:6154
glBindBufferBase = _link_function('glBindBufferBase', None, [GLenum, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6155
glTransformFeedbackVaryings = _link_function('glTransformFeedbackVaryings', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum], 'VERSION_3_0')
# GL/glext.h:6156
glGetTransformFeedbackVarying = _link_function('glGetTransformFeedbackVarying', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)], 'VERSION_3_0')
# GL/glext.h:6157
glClampColor = _link_function('glClampColor', None, [GLenum, GLenum], 'VERSION_3_0')
# GL/glext.h:6158
glBeginConditionalRender = _link_function('glBeginConditionalRender', None, [GLuint, GLenum], 'VERSION_3_0')
# GL/glext.h:6159
glEndConditionalRender = _link_function('glEndConditionalRender', None, [], 'VERSION_3_0')
# GL/glext.h:6160
glVertexAttribIPointer = _link_function('glVertexAttribIPointer', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'VERSION_3_0')
# GL/glext.h:6161
glGetVertexAttribIiv = _link_function('glGetVertexAttribIiv', None, [GLuint, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6162
glGetVertexAttribIuiv = _link_function('glGetVertexAttribIuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6163
glVertexAttribI1i = _link_function('glVertexAttribI1i', None, [GLuint, GLint], 'VERSION_3_0')
# GL/glext.h:6164
glVertexAttribI2i = _link_function('glVertexAttribI2i', None, [GLuint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:6165
glVertexAttribI3i = _link_function('glVertexAttribI3i', None, [GLuint, GLint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:6166
glVertexAttribI4i = _link_function('glVertexAttribI4i', None, [GLuint, GLint, GLint, GLint, GLint], 'VERSION_3_0')
# GL/glext.h:6167
glVertexAttribI1ui = _link_function('glVertexAttribI1ui', None, [GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6168
glVertexAttribI2ui = _link_function('glVertexAttribI2ui', None, [GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6169
glVertexAttribI3ui = _link_function('glVertexAttribI3ui', None, [GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6170
glVertexAttribI4ui = _link_function('glVertexAttribI4ui', None, [GLuint, GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6171
glVertexAttribI1iv = _link_function('glVertexAttribI1iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6172
glVertexAttribI2iv = _link_function('glVertexAttribI2iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6173
glVertexAttribI3iv = _link_function('glVertexAttribI3iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6174
glVertexAttribI4iv = _link_function('glVertexAttribI4iv', None, [GLuint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6175
glVertexAttribI1uiv = _link_function('glVertexAttribI1uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6176
glVertexAttribI2uiv = _link_function('glVertexAttribI2uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6177
glVertexAttribI3uiv = _link_function('glVertexAttribI3uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6178
glVertexAttribI4uiv = _link_function('glVertexAttribI4uiv', None, [GLuint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6179
glVertexAttribI4bv = _link_function('glVertexAttribI4bv', None, [GLuint, POINTER(GLbyte)], 'VERSION_3_0')
# GL/glext.h:6180
glVertexAttribI4sv = _link_function('glVertexAttribI4sv', None, [GLuint, POINTER(GLshort)], 'VERSION_3_0')
# GL/glext.h:6181
glVertexAttribI4ubv = _link_function('glVertexAttribI4ubv', None, [GLuint, POINTER(GLubyte)], 'VERSION_3_0')
# GL/glext.h:6182
glVertexAttribI4usv = _link_function('glVertexAttribI4usv', None, [GLuint, POINTER(GLushort)], 'VERSION_3_0')
# GL/glext.h:6183
glGetUniformuiv = _link_function('glGetUniformuiv', None, [GLuint, GLint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6184
glBindFragDataLocation = _link_function('glBindFragDataLocation', None, [GLuint, GLuint, POINTER(GLchar)], 'VERSION_3_0')
# GL/glext.h:6185
glGetFragDataLocation = _link_function('glGetFragDataLocation', GLint, [GLuint, POINTER(GLchar)], 'VERSION_3_0')
# GL/glext.h:6186
glUniform1ui = _link_function('glUniform1ui', None, [GLint, GLuint], 'VERSION_3_0')
# GL/glext.h:6187
glUniform2ui = _link_function('glUniform2ui', None, [GLint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6188
glUniform3ui = _link_function('glUniform3ui', None, [GLint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6189
glUniform4ui = _link_function('glUniform4ui', None, [GLint, GLuint, GLuint, GLuint, GLuint], 'VERSION_3_0')
# GL/glext.h:6190
glUniform1uiv = _link_function('glUniform1uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6191
glUniform2uiv = _link_function('glUniform2uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6192
glUniform3uiv = _link_function('glUniform3uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6193
glUniform4uiv = _link_function('glUniform4uiv', None, [GLint, GLsizei, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6194
glTexParameterIiv = _link_function('glTexParameterIiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6195
glTexParameterIuiv = _link_function('glTexParameterIuiv', None, [GLenum, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6196
glGetTexParameterIiv = _link_function('glGetTexParameterIiv', None, [GLenum, GLenum, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6197
glGetTexParameterIuiv = _link_function('glGetTexParameterIuiv', None, [GLenum, GLenum, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6198
glClearBufferiv = _link_function('glClearBufferiv', None, [GLenum, GLint, POINTER(GLint)], 'VERSION_3_0')
# GL/glext.h:6199
glClearBufferuiv = _link_function('glClearBufferuiv', None, [GLenum, GLint, POINTER(GLuint)], 'VERSION_3_0')
# GL/glext.h:6200
glClearBufferfv = _link_function('glClearBufferfv', None, [GLenum, GLint, POINTER(GLfloat)], 'VERSION_3_0')
# GL/glext.h:6201
glClearBufferfi = _link_function('glClearBufferfi', None, [GLenum, GLint, GLfloat, GLint], 'VERSION_3_0')
# GL/glext.h:6202
glGetStringi = _link_function('glGetStringi', POINTER(GLubyte), [GLenum, GLuint], 'VERSION_3_0')
PFNGLCOLORMASKIPROC = CFUNCTYPE(None, GLuint, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:6204
PFNGLGETBOOLEANI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLboolean)) # GL/glext.h:6205
PFNGLGETINTEGERI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:6206
PFNGLENABLEIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6207
PFNGLDISABLEIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6208
PFNGLISENABLEDIPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:6209
PFNGLBEGINTRANSFORMFEEDBACKPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:6210
PFNGLENDTRANSFORMFEEDBACKPROC = CFUNCTYPE(None) # GL/glext.h:6211
PFNGLBINDBUFFERRANGEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:6212
PFNGLBINDBUFFERBASEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:6213
PFNGLTRANSFORMFEEDBACKVARYINGSPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum) # GL/glext.h:6214
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:6215
PFNGLCLAMPCOLORPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:6216
PFNGLBEGINCONDITIONALRENDERPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:6217
PFNGLENDCONDITIONALRENDERPROC = CFUNCTYPE(None) # GL/glext.h:6218
PFNGLVERTEXATTRIBIPOINTERPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6219
PFNGLGETVERTEXATTRIBIIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6220
PFNGLGETVERTEXATTRIBIUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:6221
PFNGLVERTEXATTRIBI1IPROC = CFUNCTYPE(None, GLuint, GLint) # GL/glext.h:6222
PFNGLVERTEXATTRIBI2IPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:6223
PFNGLVERTEXATTRIBI3IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:6224
PFNGLVERTEXATTRIBI4IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:6225
PFNGLVERTEXATTRIBI1UIPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:6226
PFNGLVERTEXATTRIBI2UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:6227
PFNGLVERTEXATTRIBI3UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6228
PFNGLVERTEXATTRIBI4UIPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6229
PFNGLVERTEXATTRIBI1IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6230
PFNGLVERTEXATTRIBI2IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6231
PFNGLVERTEXATTRIBI3IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6232
PFNGLVERTEXATTRIBI4IVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6233
PFNGLVERTEXATTRIBI1UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6234
PFNGLVERTEXATTRIBI2UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6235
PFNGLVERTEXATTRIBI3UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6236
PFNGLVERTEXATTRIBI4UIVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6237
PFNGLVERTEXATTRIBI4BVPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:6238
PFNGLVERTEXATTRIBI4SVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6239
PFNGLVERTEXATTRIBI4UBVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6240
PFNGLVERTEXATTRIBI4USVPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:6241
PFNGLGETUNIFORMUIVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint)) # GL/glext.h:6242
PFNGLBINDFRAGDATALOCATIONPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:6243
PFNGLGETFRAGDATALOCATIONPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:6244
PFNGLUNIFORM1UIPROC = CFUNCTYPE(None, GLint, GLuint) # GL/glext.h:6245
PFNGLUNIFORM2UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint) # GL/glext.h:6246
PFNGLUNIFORM3UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint) # GL/glext.h:6247
PFNGLUNIFORM4UIPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:6248
PFNGLUNIFORM1UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:6249
PFNGLUNIFORM2UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:6250
PFNGLUNIFORM3UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:6251
PFNGLUNIFORM4UIVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:6252
PFNGLTEXPARAMETERIIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6253
PFNGLTEXPARAMETERIUIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:6254
PFNGLGETTEXPARAMETERIIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6255
PFNGLGETTEXPARAMETERIUIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:6256
PFNGLCLEARBUFFERIVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLint)) # GL/glext.h:6257
PFNGLCLEARBUFFERUIVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLuint)) # GL/glext.h:6258
PFNGLCLEARBUFFERFVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLfloat)) # GL/glext.h:6259
PFNGLCLEARBUFFERFIPROC = CFUNCTYPE(None, GLenum, GLint, GLfloat, GLint) # GL/glext.h:6260
PFNGLGETSTRINGIPROC = CFUNCTYPE(POINTER(GLubyte), GLenum, GLuint) # GL/glext.h:6261
# VERSION_3_1 (GL/glext.h:6264)
GL_VERSION_3_1 = 1 # GL/glext.h:6265
# GL/glext.h:6270
glDrawArraysInstanced = _link_function('glDrawArraysInstanced', None, [GLenum, GLint, GLsizei, GLsizei], 'VERSION_3_1')
# GL/glext.h:6271
glDrawElementsInstanced = _link_function('glDrawElementsInstanced', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei], 'VERSION_3_1')
# GL/glext.h:6272
glTexBuffer = _link_function('glTexBuffer', None, [GLenum, GLenum, GLuint], 'VERSION_3_1')
# GL/glext.h:6273
glPrimitiveRestartIndex = _link_function('glPrimitiveRestartIndex', None, [GLuint], 'VERSION_3_1')
PFNGLDRAWARRAYSINSTANCEDPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:6275
PFNGLDRAWELEMENTSINSTANCEDPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:6276
PFNGLTEXBUFFERPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:6277
PFNGLPRIMITIVERESTARTINDEXPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6278
# VERSION_3_2 (GL/glext.h:6281)
GL_VERSION_3_2 = 1 # GL/glext.h:6282
# GL/glext.h:6289
glGetInteger64i_v = _link_function('glGetInteger64i_v', None, [GLenum, GLuint, POINTER(GLint64)], 'VERSION_3_2')
# GL/glext.h:6290
glGetBufferParameteri64v = _link_function('glGetBufferParameteri64v', None, [GLenum, GLenum, POINTER(GLint64)], 'VERSION_3_2')
# GL/glext.h:6291
glFramebufferTexture = _link_function('glFramebufferTexture', None, [GLenum, GLenum, GLuint, GLint], 'VERSION_3_2')
PFNGLGETINTEGER64I_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint64)) # GL/glext.h:6293
PFNGLGETBUFFERPARAMETERI64VPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint64)) # GL/glext.h:6294
PFNGLFRAMEBUFFERTEXTUREPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint) # GL/glext.h:6295
# VERSION_3_3 (GL/glext.h:6298)
GL_VERSION_3_3 = 1 # GL/glext.h:6299
# GL/glext.h:6311
glVertexAttribDivisor = _link_function('glVertexAttribDivisor', None, [GLuint, GLuint], 'VERSION_3_3')
PFNGLVERTEXATTRIBDIVISORPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:6313
# VERSION_4_0 (GL/glext.h:6316)
GL_VERSION_4_0 = 1 # GL/glext.h:6317
# GL/glext.h:6331
glMinSampleShading = _link_function('glMinSampleShading', None, [GLfloat], 'VERSION_4_0')
# GL/glext.h:6332
glBlendEquationi = _link_function('glBlendEquationi', None, [GLuint, GLenum], 'VERSION_4_0')
# GL/glext.h:6333
glBlendEquationSeparatei = _link_function('glBlendEquationSeparatei', None, [GLuint, GLenum, GLenum], 'VERSION_4_0')
# GL/glext.h:6334
glBlendFunci = _link_function('glBlendFunci', None, [GLuint, GLenum, GLenum], 'VERSION_4_0')
# GL/glext.h:6335
glBlendFuncSeparatei = _link_function('glBlendFuncSeparatei', None, [GLuint, GLenum, GLenum, GLenum, GLenum], 'VERSION_4_0')
PFNGLMINSAMPLESHADINGPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:6337
PFNGLBLENDEQUATIONIPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:6338
PFNGLBLENDEQUATIONSEPARATEIPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:6339
PFNGLBLENDFUNCIPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:6340
PFNGLBLENDFUNCSEPARATEIPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:6341
# VERSION_4_1 (GL/glext.h:6344)
GL_VERSION_4_1 = 1 # GL/glext.h:6345
# VERSION_4_2 (GL/glext.h:6355)
GL_VERSION_4_2 = 1 # GL/glext.h:6356
# ARB_multitexture (GL/glext.h:6371)
# ARB_transpose_matrix (GL/glext.h:6445)
GL_ARB_transpose_matrix = 1 # GL/glext.h:6446
# GL/glext.h:6448
glLoadTransposeMatrixfARB = _link_function('glLoadTransposeMatrixfARB', None, [POINTER(GLfloat)], 'ARB_transpose_matrix')
# GL/glext.h:6449
glLoadTransposeMatrixdARB = _link_function('glLoadTransposeMatrixdARB', None, [POINTER(GLdouble)], 'ARB_transpose_matrix')
# GL/glext.h:6450
glMultTransposeMatrixfARB = _link_function('glMultTransposeMatrixfARB', None, [POINTER(GLfloat)], 'ARB_transpose_matrix')
# GL/glext.h:6451
glMultTransposeMatrixdARB = _link_function('glMultTransposeMatrixdARB', None, [POINTER(GLdouble)], 'ARB_transpose_matrix')
PFNGLLOADTRANSPOSEMATRIXFARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6453
PFNGLLOADTRANSPOSEMATRIXDARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6454
PFNGLMULTTRANSPOSEMATRIXFARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6455
PFNGLMULTTRANSPOSEMATRIXDARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6456
# ARB_multisample (GL/glext.h:6459)
GL_ARB_multisample = 1 # GL/glext.h:6460
# GL/glext.h:6462
glSampleCoverageARB = _link_function('glSampleCoverageARB', None, [GLfloat, GLboolean], 'ARB_multisample')
PFNGLSAMPLECOVERAGEARBPROC = CFUNCTYPE(None, GLfloat, GLboolean) # GL/glext.h:6464
# ARB_texture_env_add (GL/glext.h:6467)
GL_ARB_texture_env_add = 1 # GL/glext.h:6468
# ARB_texture_cube_map (GL/glext.h:6471)
GL_ARB_texture_cube_map = 1 # GL/glext.h:6472
# ARB_texture_compression (GL/glext.h:6475)
GL_ARB_texture_compression = 1 # GL/glext.h:6476
# GL/glext.h:6478
glCompressedTexImage3DARB = _link_function('glCompressedTexImage3DARB', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6479
glCompressedTexImage2DARB = _link_function('glCompressedTexImage2DARB', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6480
glCompressedTexImage1DARB = _link_function('glCompressedTexImage1DARB', None, [GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6481
glCompressedTexSubImage3DARB = _link_function('glCompressedTexSubImage3DARB', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6482
glCompressedTexSubImage2DARB = _link_function('glCompressedTexSubImage2DARB', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6483
glCompressedTexSubImage1DARB = _link_function('glCompressedTexSubImage1DARB', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_texture_compression')
# GL/glext.h:6484
glGetCompressedTexImageARB = _link_function('glGetCompressedTexImageARB', None, [GLenum, GLint, POINTER(GLvoid)], 'ARB_texture_compression')
PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:6486
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:6487
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:6488
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6489
PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6490
PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6491
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:6492
# ARB_texture_border_clamp (GL/glext.h:6495)
GL_ARB_texture_border_clamp = 1 # GL/glext.h:6496
# ARB_point_parameters (GL/glext.h:6499)
GL_ARB_point_parameters = 1 # GL/glext.h:6500
# GL/glext.h:6502
glPointParameterfARB = _link_function('glPointParameterfARB', None, [GLenum, GLfloat], 'ARB_point_parameters')
# GL/glext.h:6503
glPointParameterfvARB = _link_function('glPointParameterfvARB', None, [GLenum, POINTER(GLfloat)], 'ARB_point_parameters')
PFNGLPOINTPARAMETERFARBPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:6505
PFNGLPOINTPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:6506
# ARB_vertex_blend (GL/glext.h:6509)
GL_ARB_vertex_blend = 1 # GL/glext.h:6510
# GL/glext.h:6512
glWeightbvARB = _link_function('glWeightbvARB', None, [GLint, POINTER(GLbyte)], 'ARB_vertex_blend')
# GL/glext.h:6513
glWeightsvARB = _link_function('glWeightsvARB', None, [GLint, POINTER(GLshort)], 'ARB_vertex_blend')
# GL/glext.h:6514
glWeightivARB = _link_function('glWeightivARB', None, [GLint, POINTER(GLint)], 'ARB_vertex_blend')
# GL/glext.h:6515
glWeightfvARB = _link_function('glWeightfvARB', None, [GLint, POINTER(GLfloat)], 'ARB_vertex_blend')
# GL/glext.h:6516
glWeightdvARB = _link_function('glWeightdvARB', None, [GLint, POINTER(GLdouble)], 'ARB_vertex_blend')
# GL/glext.h:6517
glWeightubvARB = _link_function('glWeightubvARB', None, [GLint, POINTER(GLubyte)], 'ARB_vertex_blend')
# GL/glext.h:6518
glWeightusvARB = _link_function('glWeightusvARB', None, [GLint, POINTER(GLushort)], 'ARB_vertex_blend')
# GL/glext.h:6519
glWeightuivARB = _link_function('glWeightuivARB', None, [GLint, POINTER(GLuint)], 'ARB_vertex_blend')
# GL/glext.h:6520
glWeightPointerARB = _link_function('glWeightPointerARB', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_vertex_blend')
# GL/glext.h:6521
glVertexBlendARB = _link_function('glVertexBlendARB', None, [GLint], 'ARB_vertex_blend')
PFNGLWEIGHTBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLbyte)) # GL/glext.h:6523
PFNGLWEIGHTSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLshort)) # GL/glext.h:6524
PFNGLWEIGHTIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLint)) # GL/glext.h:6525
PFNGLWEIGHTFVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLfloat)) # GL/glext.h:6526
PFNGLWEIGHTDVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLdouble)) # GL/glext.h:6527
PFNGLWEIGHTUBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLubyte)) # GL/glext.h:6528
PFNGLWEIGHTUSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLushort)) # GL/glext.h:6529
PFNGLWEIGHTUIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLuint)) # GL/glext.h:6530
PFNGLWEIGHTPOINTERARBPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6531
PFNGLVERTEXBLENDARBPROC = CFUNCTYPE(None, GLint) # GL/glext.h:6532
# ARB_matrix_palette (GL/glext.h:6535)
GL_ARB_matrix_palette = 1 # GL/glext.h:6536
# GL/glext.h:6538
glCurrentPaletteMatrixARB = _link_function('glCurrentPaletteMatrixARB', None, [GLint], 'ARB_matrix_palette')
# GL/glext.h:6539
glMatrixIndexubvARB = _link_function('glMatrixIndexubvARB', None, [GLint, POINTER(GLubyte)], 'ARB_matrix_palette')
# GL/glext.h:6540
glMatrixIndexusvARB = _link_function('glMatrixIndexusvARB', None, [GLint, POINTER(GLushort)], 'ARB_matrix_palette')
# GL/glext.h:6541
glMatrixIndexuivARB = _link_function('glMatrixIndexuivARB', None, [GLint, POINTER(GLuint)], 'ARB_matrix_palette')
# GL/glext.h:6542
glMatrixIndexPointerARB = _link_function('glMatrixIndexPointerARB', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_matrix_palette')
PFNGLCURRENTPALETTEMATRIXARBPROC = CFUNCTYPE(None, GLint) # GL/glext.h:6544
PFNGLMATRIXINDEXUBVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLubyte)) # GL/glext.h:6545
PFNGLMATRIXINDEXUSVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLushort)) # GL/glext.h:6546
PFNGLMATRIXINDEXUIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLuint)) # GL/glext.h:6547
PFNGLMATRIXINDEXPOINTERARBPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6548
# ARB_texture_env_combine (GL/glext.h:6551)
GL_ARB_texture_env_combine = 1 # GL/glext.h:6552
# ARB_texture_env_crossbar (GL/glext.h:6555)
GL_ARB_texture_env_crossbar = 1 # GL/glext.h:6556
# ARB_texture_env_dot3 (GL/glext.h:6559)
GL_ARB_texture_env_dot3 = 1 # GL/glext.h:6560
# ARB_texture_mirrored_repeat (GL/glext.h:6563)
GL_ARB_texture_mirrored_repeat = 1 # GL/glext.h:6564
# ARB_depth_texture (GL/glext.h:6567)
GL_ARB_depth_texture = 1 # GL/glext.h:6568
# ARB_shadow (GL/glext.h:6571)
GL_ARB_shadow = 1 # GL/glext.h:6572
# ARB_shadow_ambient (GL/glext.h:6575)
GL_ARB_shadow_ambient = 1 # GL/glext.h:6576
# ARB_window_pos (GL/glext.h:6579)
GL_ARB_window_pos = 1 # GL/glext.h:6580
# GL/glext.h:6582
glWindowPos2dARB = _link_function('glWindowPos2dARB', None, [GLdouble, GLdouble], 'ARB_window_pos')
# GL/glext.h:6583
glWindowPos2dvARB = _link_function('glWindowPos2dvARB', None, [POINTER(GLdouble)], 'ARB_window_pos')
# GL/glext.h:6584
glWindowPos2fARB = _link_function('glWindowPos2fARB', None, [GLfloat, GLfloat], 'ARB_window_pos')
# GL/glext.h:6585
glWindowPos2fvARB = _link_function('glWindowPos2fvARB', None, [POINTER(GLfloat)], 'ARB_window_pos')
# GL/glext.h:6586
glWindowPos2iARB = _link_function('glWindowPos2iARB', None, [GLint, GLint], 'ARB_window_pos')
# GL/glext.h:6587
glWindowPos2ivARB = _link_function('glWindowPos2ivARB', None, [POINTER(GLint)], 'ARB_window_pos')
# GL/glext.h:6588
glWindowPos2sARB = _link_function('glWindowPos2sARB', None, [GLshort, GLshort], 'ARB_window_pos')
# GL/glext.h:6589
glWindowPos2svARB = _link_function('glWindowPos2svARB', None, [POINTER(GLshort)], 'ARB_window_pos')
# GL/glext.h:6590
glWindowPos3dARB = _link_function('glWindowPos3dARB', None, [GLdouble, GLdouble, GLdouble], 'ARB_window_pos')
# GL/glext.h:6591
glWindowPos3dvARB = _link_function('glWindowPos3dvARB', None, [POINTER(GLdouble)], 'ARB_window_pos')
# GL/glext.h:6592
glWindowPos3fARB = _link_function('glWindowPos3fARB', None, [GLfloat, GLfloat, GLfloat], 'ARB_window_pos')
# GL/glext.h:6593
glWindowPos3fvARB = _link_function('glWindowPos3fvARB', None, [POINTER(GLfloat)], 'ARB_window_pos')
# GL/glext.h:6594
glWindowPos3iARB = _link_function('glWindowPos3iARB', None, [GLint, GLint, GLint], 'ARB_window_pos')
# GL/glext.h:6595
glWindowPos3ivARB = _link_function('glWindowPos3ivARB', None, [POINTER(GLint)], 'ARB_window_pos')
# GL/glext.h:6596
glWindowPos3sARB = _link_function('glWindowPos3sARB', None, [GLshort, GLshort, GLshort], 'ARB_window_pos')
# GL/glext.h:6597
glWindowPos3svARB = _link_function('glWindowPos3svARB', None, [POINTER(GLshort)], 'ARB_window_pos')
PFNGLWINDOWPOS2DARBPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:6599
PFNGLWINDOWPOS2DVARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6600
PFNGLWINDOWPOS2FARBPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:6601
PFNGLWINDOWPOS2FVARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6602
PFNGLWINDOWPOS2IARBPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:6603
PFNGLWINDOWPOS2IVARBPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6604
PFNGLWINDOWPOS2SARBPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:6605
PFNGLWINDOWPOS2SVARBPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6606
PFNGLWINDOWPOS3DARBPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:6607
PFNGLWINDOWPOS3DVARBPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:6608
PFNGLWINDOWPOS3FARBPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:6609
PFNGLWINDOWPOS3FVARBPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:6610
PFNGLWINDOWPOS3IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6611
PFNGLWINDOWPOS3IVARBPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:6612
PFNGLWINDOWPOS3SARBPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:6613
PFNGLWINDOWPOS3SVARBPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:6614
# ARB_vertex_program (GL/glext.h:6617)
GL_ARB_vertex_program = 1 # GL/glext.h:6618
# GL/glext.h:6620
glVertexAttrib1dARB = _link_function('glVertexAttrib1dARB', None, [GLuint, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6621
glVertexAttrib1dvARB = _link_function('glVertexAttrib1dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6622
glVertexAttrib1fARB = _link_function('glVertexAttrib1fARB', None, [GLuint, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6623
glVertexAttrib1fvARB = _link_function('glVertexAttrib1fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6624
glVertexAttrib1sARB = _link_function('glVertexAttrib1sARB', None, [GLuint, GLshort], 'ARB_vertex_program')
# GL/glext.h:6625
glVertexAttrib1svARB = _link_function('glVertexAttrib1svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:6626
glVertexAttrib2dARB = _link_function('glVertexAttrib2dARB', None, [GLuint, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6627
glVertexAttrib2dvARB = _link_function('glVertexAttrib2dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6628
glVertexAttrib2fARB = _link_function('glVertexAttrib2fARB', None, [GLuint, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6629
glVertexAttrib2fvARB = _link_function('glVertexAttrib2fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6630
glVertexAttrib2sARB = _link_function('glVertexAttrib2sARB', None, [GLuint, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:6631
glVertexAttrib2svARB = _link_function('glVertexAttrib2svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:6632
glVertexAttrib3dARB = _link_function('glVertexAttrib3dARB', None, [GLuint, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6633
glVertexAttrib3dvARB = _link_function('glVertexAttrib3dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6634
glVertexAttrib3fARB = _link_function('glVertexAttrib3fARB', None, [GLuint, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6635
glVertexAttrib3fvARB = _link_function('glVertexAttrib3fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6636
glVertexAttrib3sARB = _link_function('glVertexAttrib3sARB', None, [GLuint, GLshort, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:6637
glVertexAttrib3svARB = _link_function('glVertexAttrib3svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:6638
glVertexAttrib4NbvARB = _link_function('glVertexAttrib4NbvARB', None, [GLuint, POINTER(GLbyte)], 'ARB_vertex_program')
# GL/glext.h:6639
glVertexAttrib4NivARB = _link_function('glVertexAttrib4NivARB', None, [GLuint, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:6640
glVertexAttrib4NsvARB = _link_function('glVertexAttrib4NsvARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:6641
glVertexAttrib4NubARB = _link_function('glVertexAttrib4NubARB', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'ARB_vertex_program')
# GL/glext.h:6642
glVertexAttrib4NubvARB = _link_function('glVertexAttrib4NubvARB', None, [GLuint, POINTER(GLubyte)], 'ARB_vertex_program')
# GL/glext.h:6643
glVertexAttrib4NuivARB = _link_function('glVertexAttrib4NuivARB', None, [GLuint, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:6644
glVertexAttrib4NusvARB = _link_function('glVertexAttrib4NusvARB', None, [GLuint, POINTER(GLushort)], 'ARB_vertex_program')
# GL/glext.h:6645
glVertexAttrib4bvARB = _link_function('glVertexAttrib4bvARB', None, [GLuint, POINTER(GLbyte)], 'ARB_vertex_program')
# GL/glext.h:6646
glVertexAttrib4dARB = _link_function('glVertexAttrib4dARB', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6647
glVertexAttrib4dvARB = _link_function('glVertexAttrib4dvARB', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6648
glVertexAttrib4fARB = _link_function('glVertexAttrib4fARB', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6649
glVertexAttrib4fvARB = _link_function('glVertexAttrib4fvARB', None, [GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6650
glVertexAttrib4ivARB = _link_function('glVertexAttrib4ivARB', None, [GLuint, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:6651
glVertexAttrib4sARB = _link_function('glVertexAttrib4sARB', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'ARB_vertex_program')
# GL/glext.h:6652
glVertexAttrib4svARB = _link_function('glVertexAttrib4svARB', None, [GLuint, POINTER(GLshort)], 'ARB_vertex_program')
# GL/glext.h:6653
glVertexAttrib4ubvARB = _link_function('glVertexAttrib4ubvARB', None, [GLuint, POINTER(GLubyte)], 'ARB_vertex_program')
# GL/glext.h:6654
glVertexAttrib4uivARB = _link_function('glVertexAttrib4uivARB', None, [GLuint, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:6655
glVertexAttrib4usvARB = _link_function('glVertexAttrib4usvARB', None, [GLuint, POINTER(GLushort)], 'ARB_vertex_program')
# GL/glext.h:6656
glVertexAttribPointerARB = _link_function('glVertexAttribPointerARB', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:6657
glEnableVertexAttribArrayARB = _link_function('glEnableVertexAttribArrayARB', None, [GLuint], 'ARB_vertex_program')
# GL/glext.h:6658
glDisableVertexAttribArrayARB = _link_function('glDisableVertexAttribArrayARB', None, [GLuint], 'ARB_vertex_program')
# GL/glext.h:6659
glProgramStringARB = _link_function('glProgramStringARB', None, [GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:6660
glBindProgramARB = _link_function('glBindProgramARB', None, [GLenum, GLuint], 'ARB_vertex_program')
# GL/glext.h:6661
glDeleteProgramsARB = _link_function('glDeleteProgramsARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:6662
glGenProgramsARB = _link_function('glGenProgramsARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_program')
# GL/glext.h:6663
glProgramEnvParameter4dARB = _link_function('glProgramEnvParameter4dARB', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6664
glProgramEnvParameter4dvARB = _link_function('glProgramEnvParameter4dvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6665
glProgramEnvParameter4fARB = _link_function('glProgramEnvParameter4fARB', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6666
glProgramEnvParameter4fvARB = _link_function('glProgramEnvParameter4fvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6667
glProgramLocalParameter4dARB = _link_function('glProgramLocalParameter4dARB', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_program')
# GL/glext.h:6668
glProgramLocalParameter4dvARB = _link_function('glProgramLocalParameter4dvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6669
glProgramLocalParameter4fARB = _link_function('glProgramLocalParameter4fARB', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_vertex_program')
# GL/glext.h:6670
glProgramLocalParameter4fvARB = _link_function('glProgramLocalParameter4fvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6671
glGetProgramEnvParameterdvARB = _link_function('glGetProgramEnvParameterdvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6672
glGetProgramEnvParameterfvARB = _link_function('glGetProgramEnvParameterfvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6673
glGetProgramLocalParameterdvARB = _link_function('glGetProgramLocalParameterdvARB', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6674
glGetProgramLocalParameterfvARB = _link_function('glGetProgramLocalParameterfvARB', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6675
glGetProgramivARB = _link_function('glGetProgramivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:6676
glGetProgramStringARB = _link_function('glGetProgramStringARB', None, [GLenum, GLenum, POINTER(GLvoid)], 'ARB_vertex_program')
# GL/glext.h:6677
glGetVertexAttribdvARB = _link_function('glGetVertexAttribdvARB', None, [GLuint, GLenum, POINTER(GLdouble)], 'ARB_vertex_program')
# GL/glext.h:6678
glGetVertexAttribfvARB = _link_function('glGetVertexAttribfvARB', None, [GLuint, GLenum, POINTER(GLfloat)], 'ARB_vertex_program')
# GL/glext.h:6679
glGetVertexAttribivARB = _link_function('glGetVertexAttribivARB', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_vertex_program')
# GL/glext.h:6680
glGetVertexAttribPointervARB = _link_function('glGetVertexAttribPointervARB', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'ARB_vertex_program')
# GL/glext.h:6681
glIsProgramARB = _link_function('glIsProgramARB', GLboolean, [GLuint], 'ARB_vertex_program')
PFNGLVERTEXATTRIB1DARBPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:6683
PFNGLVERTEXATTRIB1DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6684
PFNGLVERTEXATTRIB1FARBPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:6685
PFNGLVERTEXATTRIB1FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6686
PFNGLVERTEXATTRIB1SARBPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:6687
PFNGLVERTEXATTRIB1SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6688
PFNGLVERTEXATTRIB2DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:6689
PFNGLVERTEXATTRIB2DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6690
PFNGLVERTEXATTRIB2FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:6691
PFNGLVERTEXATTRIB2FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6692
PFNGLVERTEXATTRIB2SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:6693
PFNGLVERTEXATTRIB2SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6694
PFNGLVERTEXATTRIB3DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:6695
PFNGLVERTEXATTRIB3DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6696
PFNGLVERTEXATTRIB3FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6697
PFNGLVERTEXATTRIB3FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6698
PFNGLVERTEXATTRIB3SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:6699
PFNGLVERTEXATTRIB3SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6700
PFNGLVERTEXATTRIB4NBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:6701
PFNGLVERTEXATTRIB4NIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6702
PFNGLVERTEXATTRIB4NSVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6703
PFNGLVERTEXATTRIB4NUBARBPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:6704
PFNGLVERTEXATTRIB4NUBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6705
PFNGLVERTEXATTRIB4NUIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6706
PFNGLVERTEXATTRIB4NUSVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:6707
PFNGLVERTEXATTRIB4BVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:6708
PFNGLVERTEXATTRIB4DARBPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6709
PFNGLVERTEXATTRIB4DVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:6710
PFNGLVERTEXATTRIB4FARBPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6711
PFNGLVERTEXATTRIB4FVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:6712
PFNGLVERTEXATTRIB4IVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:6713
PFNGLVERTEXATTRIB4SARBPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:6714
PFNGLVERTEXATTRIB4SVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:6715
PFNGLVERTEXATTRIB4UBVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:6716
PFNGLVERTEXATTRIB4UIVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:6717
PFNGLVERTEXATTRIB4USVARBPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:6718
PFNGLVERTEXATTRIBPOINTERARBPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, POINTER(GLvoid)) # GL/glext.h:6719
PFNGLENABLEVERTEXATTRIBARRAYARBPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6720
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:6721
PFNGLPROGRAMSTRINGARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:6722
PFNGLBINDPROGRAMARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6723
PFNGLDELETEPROGRAMSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6724
PFNGLGENPROGRAMSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6725
PFNGLPROGRAMENVPARAMETER4DARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6726
PFNGLPROGRAMENVPARAMETER4DVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:6727
PFNGLPROGRAMENVPARAMETER4FARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6728
PFNGLPROGRAMENVPARAMETER4FVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6729
PFNGLPROGRAMLOCALPARAMETER4DARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:6730
PFNGLPROGRAMLOCALPARAMETER4DVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:6731
PFNGLPROGRAMLOCALPARAMETER4FARBPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6732
PFNGLPROGRAMLOCALPARAMETER4FVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6733
PFNGLGETPROGRAMENVPARAMETERDVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:6734
PFNGLGETPROGRAMENVPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6735
PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:6736
PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:6737
PFNGLGETPROGRAMIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6738
PFNGLGETPROGRAMSTRINGARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:6739
PFNGLGETVERTEXATTRIBDVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:6740
PFNGLGETVERTEXATTRIBFVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:6741
PFNGLGETVERTEXATTRIBIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6742
PFNGLGETVERTEXATTRIBPOINTERVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:6743
PFNGLISPROGRAMARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6744
# ARB_fragment_program (GL/glext.h:6747)
GL_ARB_fragment_program = 1 # GL/glext.h:6748
# ARB_vertex_buffer_object (GL/glext.h:6752)
GL_ARB_vertex_buffer_object = 1 # GL/glext.h:6753
# GL/glext.h:6755
glBindBufferARB = _link_function('glBindBufferARB', None, [GLenum, GLuint], 'ARB_vertex_buffer_object')
# GL/glext.h:6756
glDeleteBuffersARB = _link_function('glDeleteBuffersARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_buffer_object')
# GL/glext.h:6757
glGenBuffersARB = _link_function('glGenBuffersARB', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_buffer_object')
# GL/glext.h:6758
glIsBufferARB = _link_function('glIsBufferARB', GLboolean, [GLuint], 'ARB_vertex_buffer_object')
# GL/glext.h:6759
glBufferDataARB = _link_function('glBufferDataARB', None, [GLenum, GLsizeiptrARB, POINTER(GLvoid), GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:6760
glBufferSubDataARB = _link_function('glBufferSubDataARB', None, [GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)], 'ARB_vertex_buffer_object')
# GL/glext.h:6761
glGetBufferSubDataARB = _link_function('glGetBufferSubDataARB', None, [GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)], 'ARB_vertex_buffer_object')
# GL/glext.h:6762
glMapBufferARB = _link_function('glMapBufferARB', POINTER(GLvoid), [GLenum, GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:6763
glUnmapBufferARB = _link_function('glUnmapBufferARB', GLboolean, [GLenum], 'ARB_vertex_buffer_object')
# GL/glext.h:6764
glGetBufferParameterivARB = _link_function('glGetBufferParameterivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_vertex_buffer_object')
# GL/glext.h:6765
glGetBufferPointervARB = _link_function('glGetBufferPointervARB', None, [GLenum, GLenum, POINTER(POINTER(GLvoid))], 'ARB_vertex_buffer_object')
PFNGLBINDBUFFERARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6767
PFNGLDELETEBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6768
PFNGLGENBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6769
PFNGLISBUFFERARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6770
PFNGLBUFFERDATAARBPROC = CFUNCTYPE(None, GLenum, GLsizeiptrARB, POINTER(GLvoid), GLenum) # GL/glext.h:6771
PFNGLBUFFERSUBDATAARBPROC = CFUNCTYPE(None, GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)) # GL/glext.h:6772
PFNGLGETBUFFERSUBDATAARBPROC = CFUNCTYPE(None, GLenum, GLintptrARB, GLsizeiptrARB, POINTER(GLvoid)) # GL/glext.h:6773
PFNGLMAPBUFFERARBPROC = CFUNCTYPE(POINTER(GLvoid), GLenum, GLenum) # GL/glext.h:6774
PFNGLUNMAPBUFFERARBPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:6775
PFNGLGETBUFFERPARAMETERIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6776
PFNGLGETBUFFERPOINTERVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:6777
# ARB_occlusion_query (GL/glext.h:6780)
GL_ARB_occlusion_query = 1 # GL/glext.h:6781
# GL/glext.h:6783
glGenQueriesARB = _link_function('glGenQueriesARB', None, [GLsizei, POINTER(GLuint)], 'ARB_occlusion_query')
# GL/glext.h:6784
glDeleteQueriesARB = _link_function('glDeleteQueriesARB', None, [GLsizei, POINTER(GLuint)], 'ARB_occlusion_query')
# GL/glext.h:6785
glIsQueryARB = _link_function('glIsQueryARB', GLboolean, [GLuint], 'ARB_occlusion_query')
# GL/glext.h:6786
glBeginQueryARB = _link_function('glBeginQueryARB', None, [GLenum, GLuint], 'ARB_occlusion_query')
# GL/glext.h:6787
glEndQueryARB = _link_function('glEndQueryARB', None, [GLenum], 'ARB_occlusion_query')
# GL/glext.h:6788
glGetQueryivARB = _link_function('glGetQueryivARB', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_occlusion_query')
# GL/glext.h:6789
glGetQueryObjectivARB = _link_function('glGetQueryObjectivARB', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_occlusion_query')
# GL/glext.h:6790
glGetQueryObjectuivARB = _link_function('glGetQueryObjectuivARB', None, [GLuint, GLenum, POINTER(GLuint)], 'ARB_occlusion_query')
PFNGLGENQUERIESARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6792
PFNGLDELETEQUERIESARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6793
PFNGLISQUERYARBPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6794
PFNGLBEGINQUERYARBPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6795
PFNGLENDQUERYARBPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:6796
PFNGLGETQUERYIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6797
PFNGLGETQUERYOBJECTIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:6798
PFNGLGETQUERYOBJECTUIVARBPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:6799
# ARB_shader_objects (GL/glext.h:6802)
GL_ARB_shader_objects = 1 # GL/glext.h:6803
# GL/glext.h:6805
glDeleteObjectARB = _link_function('glDeleteObjectARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6806
glGetHandleARB = _link_function('glGetHandleARB', GLhandleARB, [GLenum], 'ARB_shader_objects')
# GL/glext.h:6807
glDetachObjectARB = _link_function('glDetachObjectARB', None, [GLhandleARB, GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6808
glCreateShaderObjectARB = _link_function('glCreateShaderObjectARB', GLhandleARB, [GLenum], 'ARB_shader_objects')
# GL/glext.h:6809
glShaderSourceARB = _link_function('glShaderSourceARB', None, [GLhandleARB, GLsizei, POINTER(POINTER(GLcharARB)), POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6810
glCompileShaderARB = _link_function('glCompileShaderARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6811
glCreateProgramObjectARB = _link_function('glCreateProgramObjectARB', GLhandleARB, [], 'ARB_shader_objects')
# GL/glext.h:6812
glAttachObjectARB = _link_function('glAttachObjectARB', None, [GLhandleARB, GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6813
glLinkProgramARB = _link_function('glLinkProgramARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6814
glUseProgramObjectARB = _link_function('glUseProgramObjectARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6815
glValidateProgramARB = _link_function('glValidateProgramARB', None, [GLhandleARB], 'ARB_shader_objects')
# GL/glext.h:6816
glUniform1fARB = _link_function('glUniform1fARB', None, [GLint, GLfloat], 'ARB_shader_objects')
# GL/glext.h:6817
glUniform2fARB = _link_function('glUniform2fARB', None, [GLint, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:6818
glUniform3fARB = _link_function('glUniform3fARB', None, [GLint, GLfloat, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:6819
glUniform4fARB = _link_function('glUniform4fARB', None, [GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_shader_objects')
# GL/glext.h:6820
glUniform1iARB = _link_function('glUniform1iARB', None, [GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:6821
glUniform2iARB = _link_function('glUniform2iARB', None, [GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:6822
glUniform3iARB = _link_function('glUniform3iARB', None, [GLint, GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:6823
glUniform4iARB = _link_function('glUniform4iARB', None, [GLint, GLint, GLint, GLint, GLint], 'ARB_shader_objects')
# GL/glext.h:6824
glUniform1fvARB = _link_function('glUniform1fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6825
glUniform2fvARB = _link_function('glUniform2fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6826
glUniform3fvARB = _link_function('glUniform3fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6827
glUniform4fvARB = _link_function('glUniform4fvARB', None, [GLint, GLsizei, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6828
glUniform1ivARB = _link_function('glUniform1ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6829
glUniform2ivARB = _link_function('glUniform2ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6830
glUniform3ivARB = _link_function('glUniform3ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6831
glUniform4ivARB = _link_function('glUniform4ivARB', None, [GLint, GLsizei, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6832
glUniformMatrix2fvARB = _link_function('glUniformMatrix2fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6833
glUniformMatrix3fvARB = _link_function('glUniformMatrix3fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6834
glUniformMatrix4fvARB = _link_function('glUniformMatrix4fvARB', None, [GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6835
glGetObjectParameterfvARB = _link_function('glGetObjectParameterfvARB', None, [GLhandleARB, GLenum, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6836
glGetObjectParameterivARB = _link_function('glGetObjectParameterivARB', None, [GLhandleARB, GLenum, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6837
glGetInfoLogARB = _link_function('glGetInfoLogARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:6838
glGetAttachedObjectsARB = _link_function('glGetAttachedObjectsARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLhandleARB)], 'ARB_shader_objects')
# GL/glext.h:6839
glGetUniformLocationARB = _link_function('glGetUniformLocationARB', GLint, [GLhandleARB, POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:6840
glGetActiveUniformARB = _link_function('glGetActiveUniformARB', None, [GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)], 'ARB_shader_objects')
# GL/glext.h:6841
glGetUniformfvARB = _link_function('glGetUniformfvARB', None, [GLhandleARB, GLint, POINTER(GLfloat)], 'ARB_shader_objects')
# GL/glext.h:6842
glGetUniformivARB = _link_function('glGetUniformivARB', None, [GLhandleARB, GLint, POINTER(GLint)], 'ARB_shader_objects')
# GL/glext.h:6843
glGetShaderSourceARB = _link_function('glGetShaderSourceARB', None, [GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)], 'ARB_shader_objects')
PFNGLDELETEOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:6845
PFNGLGETHANDLEARBPROC = CFUNCTYPE(GLhandleARB, GLenum) # GL/glext.h:6846
PFNGLDETACHOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB, GLhandleARB) # GL/glext.h:6847
PFNGLCREATESHADEROBJECTARBPROC = CFUNCTYPE(GLhandleARB, GLenum) # GL/glext.h:6848
PFNGLSHADERSOURCEARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(POINTER(GLcharARB)), POINTER(GLint)) # GL/glext.h:6849
PFNGLCOMPILESHADERARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:6850
PFNGLCREATEPROGRAMOBJECTARBPROC = CFUNCTYPE(GLhandleARB) # GL/glext.h:6851
PFNGLATTACHOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB, GLhandleARB) # GL/glext.h:6852
PFNGLLINKPROGRAMARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:6853
PFNGLUSEPROGRAMOBJECTARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:6854
PFNGLVALIDATEPROGRAMARBPROC = CFUNCTYPE(None, GLhandleARB) # GL/glext.h:6855
PFNGLUNIFORM1FARBPROC = CFUNCTYPE(None, GLint, GLfloat) # GL/glext.h:6856
PFNGLUNIFORM2FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat) # GL/glext.h:6857
PFNGLUNIFORM3FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:6858
PFNGLUNIFORM4FARBPROC = CFUNCTYPE(None, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:6859
PFNGLUNIFORM1IARBPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:6860
PFNGLUNIFORM2IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:6861
PFNGLUNIFORM3IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:6862
PFNGLUNIFORM4IARBPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:6863
PFNGLUNIFORM1FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6864
PFNGLUNIFORM2FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6865
PFNGLUNIFORM3FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6866
PFNGLUNIFORM4FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:6867
PFNGLUNIFORM1IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6868
PFNGLUNIFORM2IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6869
PFNGLUNIFORM3IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6870
PFNGLUNIFORM4IVARBPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:6871
PFNGLUNIFORMMATRIX2FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6872
PFNGLUNIFORMMATRIX3FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6873
PFNGLUNIFORMMATRIX4FVARBPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:6874
PFNGLGETOBJECTPARAMETERFVARBPROC = CFUNCTYPE(None, GLhandleARB, GLenum, POINTER(GLfloat)) # GL/glext.h:6875
PFNGLGETOBJECTPARAMETERIVARBPROC = CFUNCTYPE(None, GLhandleARB, GLenum, POINTER(GLint)) # GL/glext.h:6876
PFNGLGETINFOLOGARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)) # GL/glext.h:6877
PFNGLGETATTACHEDOBJECTSARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLhandleARB)) # GL/glext.h:6878
PFNGLGETUNIFORMLOCATIONARBPROC = CFUNCTYPE(GLint, GLhandleARB, POINTER(GLcharARB)) # GL/glext.h:6879
PFNGLGETACTIVEUNIFORMARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)) # GL/glext.h:6880
PFNGLGETUNIFORMFVARBPROC = CFUNCTYPE(None, GLhandleARB, GLint, POINTER(GLfloat)) # GL/glext.h:6881
PFNGLGETUNIFORMIVARBPROC = CFUNCTYPE(None, GLhandleARB, GLint, POINTER(GLint)) # GL/glext.h:6882
PFNGLGETSHADERSOURCEARBPROC = CFUNCTYPE(None, GLhandleARB, GLsizei, POINTER(GLsizei), POINTER(GLcharARB)) # GL/glext.h:6883
# ARB_vertex_shader (GL/glext.h:6886)
GL_ARB_vertex_shader = 1 # GL/glext.h:6887
# GL/glext.h:6889
glBindAttribLocationARB = _link_function('glBindAttribLocationARB', None, [GLhandleARB, GLuint, POINTER(GLcharARB)], 'ARB_vertex_shader')
# GL/glext.h:6890
glGetActiveAttribARB = _link_function('glGetActiveAttribARB', None, [GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)], 'ARB_vertex_shader')
# GL/glext.h:6891
glGetAttribLocationARB = _link_function('glGetAttribLocationARB', GLint, [GLhandleARB, POINTER(GLcharARB)], 'ARB_vertex_shader')
PFNGLBINDATTRIBLOCATIONARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, POINTER(GLcharARB)) # GL/glext.h:6893
PFNGLGETACTIVEATTRIBARBPROC = CFUNCTYPE(None, GLhandleARB, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLint), POINTER(GLenum), POINTER(GLcharARB)) # GL/glext.h:6894
PFNGLGETATTRIBLOCATIONARBPROC = CFUNCTYPE(GLint, GLhandleARB, POINTER(GLcharARB)) # GL/glext.h:6895
# ARB_fragment_shader (GL/glext.h:6898)
GL_ARB_fragment_shader = 1 # GL/glext.h:6899
# ARB_shading_language_100 (GL/glext.h:6902)
GL_ARB_shading_language_100 = 1 # GL/glext.h:6903
# ARB_texture_non_power_of_two (GL/glext.h:6906)
GL_ARB_texture_non_power_of_two = 1 # GL/glext.h:6907
# ARB_point_sprite (GL/glext.h:6910)
GL_ARB_point_sprite = 1 # GL/glext.h:6911
# ARB_fragment_program_shadow (GL/glext.h:6914)
GL_ARB_fragment_program_shadow = 1 # GL/glext.h:6915
# ARB_draw_buffers (GL/glext.h:6918)
GL_ARB_draw_buffers = 1 # GL/glext.h:6919
# GL/glext.h:6921
glDrawBuffersARB = _link_function('glDrawBuffersARB', None, [GLsizei, POINTER(GLenum)], 'ARB_draw_buffers')
PFNGLDRAWBUFFERSARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:6923
# ARB_texture_rectangle (GL/glext.h:6926)
GL_ARB_texture_rectangle = 1 # GL/glext.h:6927
# ARB_color_buffer_float (GL/glext.h:6930)
GL_ARB_color_buffer_float = 1 # GL/glext.h:6931
# GL/glext.h:6933
glClampColorARB = _link_function('glClampColorARB', None, [GLenum, GLenum], 'ARB_color_buffer_float')
PFNGLCLAMPCOLORARBPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:6935
# ARB_half_float_pixel (GL/glext.h:6938)
GL_ARB_half_float_pixel = 1 # GL/glext.h:6939
# ARB_texture_float (GL/glext.h:6942)
GL_ARB_texture_float = 1 # GL/glext.h:6943
# ARB_pixel_buffer_object (GL/glext.h:6946)
GL_ARB_pixel_buffer_object = 1 # GL/glext.h:6947
# ARB_depth_buffer_float (GL/glext.h:6950)
GL_ARB_depth_buffer_float = 1 # GL/glext.h:6951
# ARB_draw_instanced (GL/glext.h:6954)
GL_ARB_draw_instanced = 1 # GL/glext.h:6955
# GL/glext.h:6957
glDrawArraysInstancedARB = _link_function('glDrawArraysInstancedARB', None, [GLenum, GLint, GLsizei, GLsizei], 'ARB_draw_instanced')
# GL/glext.h:6958
glDrawElementsInstancedARB = _link_function('glDrawElementsInstancedARB', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei], 'ARB_draw_instanced')
PFNGLDRAWARRAYSINSTANCEDARBPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:6960
PFNGLDRAWELEMENTSINSTANCEDARBPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:6961
# ARB_framebuffer_object (GL/glext.h:6964)
GL_ARB_framebuffer_object = 1 # GL/glext.h:6965
# GL/glext.h:6967
glIsRenderbuffer = _link_function('glIsRenderbuffer', GLboolean, [GLuint], 'ARB_framebuffer_object')
# GL/glext.h:6968
glBindRenderbuffer = _link_function('glBindRenderbuffer', None, [GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:6969
glDeleteRenderbuffers = _link_function('glDeleteRenderbuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:6970
glGenRenderbuffers = _link_function('glGenRenderbuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:6971
glRenderbufferStorage = _link_function('glRenderbufferStorage', None, [GLenum, GLenum, GLsizei, GLsizei], 'ARB_framebuffer_object')
# GL/glext.h:6972
glGetRenderbufferParameteriv = _link_function('glGetRenderbufferParameteriv', None, [GLenum, GLenum, POINTER(GLint)], 'ARB_framebuffer_object')
# GL/glext.h:6973
glIsFramebuffer = _link_function('glIsFramebuffer', GLboolean, [GLuint], 'ARB_framebuffer_object')
# GL/glext.h:6974
glBindFramebuffer = _link_function('glBindFramebuffer', None, [GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:6975
glDeleteFramebuffers = _link_function('glDeleteFramebuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:6976
glGenFramebuffers = _link_function('glGenFramebuffers', None, [GLsizei, POINTER(GLuint)], 'ARB_framebuffer_object')
# GL/glext.h:6977
glCheckFramebufferStatus = _link_function('glCheckFramebufferStatus', GLenum, [GLenum], 'ARB_framebuffer_object')
# GL/glext.h:6978
glFramebufferTexture1D = _link_function('glFramebufferTexture1D', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:6979
glFramebufferTexture2D = _link_function('glFramebufferTexture2D', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:6980
glFramebufferTexture3D = _link_function('glFramebufferTexture3D', None, [GLenum, GLenum, GLenum, GLuint, GLint, GLint], 'ARB_framebuffer_object')
# GL/glext.h:6981
glFramebufferRenderbuffer = _link_function('glFramebufferRenderbuffer', None, [GLenum, GLenum, GLenum, GLuint], 'ARB_framebuffer_object')
# GL/glext.h:6982
glGetFramebufferAttachmentParameteriv = _link_function('glGetFramebufferAttachmentParameteriv', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'ARB_framebuffer_object')
# GL/glext.h:6983
glGenerateMipmap = _link_function('glGenerateMipmap', None, [GLenum], 'ARB_framebuffer_object')
GLbitfield = c_uint # /usr/include/GL/gl.h:151
# GL/glext.h:6984
glBlitFramebuffer = _link_function('glBlitFramebuffer', None, [GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], 'ARB_framebuffer_object')
# GL/glext.h:6985
glRenderbufferStorageMultisample = _link_function('glRenderbufferStorageMultisample', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'ARB_framebuffer_object')
# GL/glext.h:6986
glFramebufferTextureLayer = _link_function('glFramebufferTextureLayer', None, [GLenum, GLenum, GLuint, GLint, GLint], 'ARB_framebuffer_object')
PFNGLISRENDERBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6988
PFNGLBINDRENDERBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6989
PFNGLDELETERENDERBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6990
PFNGLGENRENDERBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6991
PFNGLRENDERBUFFERSTORAGEPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei) # GL/glext.h:6992
PFNGLGETRENDERBUFFERPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:6993
PFNGLISFRAMEBUFFERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:6994
PFNGLBINDFRAMEBUFFERPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:6995
PFNGLDELETEFRAMEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6996
PFNGLGENFRAMEBUFFERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:6997
PFNGLCHECKFRAMEBUFFERSTATUSPROC = CFUNCTYPE(GLenum, GLenum) # GL/glext.h:6998
PFNGLFRAMEBUFFERTEXTURE1DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:6999
PFNGLFRAMEBUFFERTEXTURE2DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:7000
PFNGLFRAMEBUFFERTEXTURE3DPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:7001
PFNGLFRAMEBUFFERRENDERBUFFERPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:7002
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7003
PFNGLGENERATEMIPMAPPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7004
PFNGLBLITFRAMEBUFFERPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) # GL/glext.h:7005
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:7006
PFNGLFRAMEBUFFERTEXTURELAYERPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:7007
# ARB_framebuffer_sRGB (GL/glext.h:7010)
GL_ARB_framebuffer_sRGB = 1 # GL/glext.h:7011
# ARB_geometry_shader4 (GL/glext.h:7014)
GL_ARB_geometry_shader4 = 1 # GL/glext.h:7015
# GL/glext.h:7017
glProgramParameteriARB = _link_function('glProgramParameteriARB', None, [GLuint, GLenum, GLint], 'ARB_geometry_shader4')
# GL/glext.h:7018
glFramebufferTextureARB = _link_function('glFramebufferTextureARB', None, [GLenum, GLenum, GLuint, GLint], 'ARB_geometry_shader4')
# GL/glext.h:7019
glFramebufferTextureLayerARB = _link_function('glFramebufferTextureLayerARB', None, [GLenum, GLenum, GLuint, GLint, GLint], 'ARB_geometry_shader4')
# GL/glext.h:7020
glFramebufferTextureFaceARB = _link_function('glFramebufferTextureFaceARB', None, [GLenum, GLenum, GLuint, GLint, GLenum], 'ARB_geometry_shader4')
PFNGLPROGRAMPARAMETERIARBPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:7022
PFNGLFRAMEBUFFERTEXTUREARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint) # GL/glext.h:7023
PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:7024
PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLenum) # GL/glext.h:7025
# ARB_half_float_vertex (GL/glext.h:7028)
GL_ARB_half_float_vertex = 1 # GL/glext.h:7029
# ARB_instanced_arrays (GL/glext.h:7032)
GL_ARB_instanced_arrays = 1 # GL/glext.h:7033
# GL/glext.h:7035
glVertexAttribDivisorARB = _link_function('glVertexAttribDivisorARB', None, [GLuint, GLuint], 'ARB_instanced_arrays')
PFNGLVERTEXATTRIBDIVISORARBPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:7037
# ARB_map_buffer_range (GL/glext.h:7040)
GL_ARB_map_buffer_range = 1 # GL/glext.h:7041
# GL/glext.h:7043
glMapBufferRange = _link_function('glMapBufferRange', POINTER(GLvoid), [GLenum, GLintptr, GLsizeiptr, GLbitfield], 'ARB_map_buffer_range')
# GL/glext.h:7044
glFlushMappedBufferRange = _link_function('glFlushMappedBufferRange', None, [GLenum, GLintptr, GLsizeiptr], 'ARB_map_buffer_range')
PFNGLMAPBUFFERRANGEPROC = CFUNCTYPE(POINTER(GLvoid), GLenum, GLintptr, GLsizeiptr, GLbitfield) # GL/glext.h:7046
PFNGLFLUSHMAPPEDBUFFERRANGEPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr) # GL/glext.h:7047
# ARB_texture_buffer_object (GL/glext.h:7050)
GL_ARB_texture_buffer_object = 1 # GL/glext.h:7051
# GL/glext.h:7053
glTexBufferARB = _link_function('glTexBufferARB', None, [GLenum, GLenum, GLuint], 'ARB_texture_buffer_object')
PFNGLTEXBUFFERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7055
# ARB_texture_compression_rgtc (GL/glext.h:7058)
GL_ARB_texture_compression_rgtc = 1 # GL/glext.h:7059
# ARB_texture_rg (GL/glext.h:7062)
GL_ARB_texture_rg = 1 # GL/glext.h:7063
# ARB_vertex_array_object (GL/glext.h:7066)
GL_ARB_vertex_array_object = 1 # GL/glext.h:7067
# GL/glext.h:7069
glBindVertexArray = _link_function('glBindVertexArray', None, [GLuint], 'ARB_vertex_array_object')
# GL/glext.h:7070
glDeleteVertexArrays = _link_function('glDeleteVertexArrays', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_array_object')
# GL/glext.h:7071
glGenVertexArrays = _link_function('glGenVertexArrays', None, [GLsizei, POINTER(GLuint)], 'ARB_vertex_array_object')
# GL/glext.h:7072
glIsVertexArray = _link_function('glIsVertexArray', GLboolean, [GLuint], 'ARB_vertex_array_object')
PFNGLBINDVERTEXARRAYPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7074
PFNGLDELETEVERTEXARRAYSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7075
PFNGLGENVERTEXARRAYSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7076
PFNGLISVERTEXARRAYPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7077
# ARB_uniform_buffer_object (GL/glext.h:7080)
GL_ARB_uniform_buffer_object = 1 # GL/glext.h:7081
# GL/glext.h:7083
glGetUniformIndices = _link_function('glGetUniformIndices', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLuint)], 'ARB_uniform_buffer_object')
# GL/glext.h:7084
glGetActiveUniformsiv = _link_function('glGetActiveUniformsiv', None, [GLuint, GLsizei, POINTER(GLuint), GLenum, POINTER(GLint)], 'ARB_uniform_buffer_object')
# GL/glext.h:7085
glGetActiveUniformName = _link_function('glGetActiveUniformName', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'ARB_uniform_buffer_object')
# GL/glext.h:7086
glGetUniformBlockIndex = _link_function('glGetUniformBlockIndex', GLuint, [GLuint, POINTER(GLchar)], 'ARB_uniform_buffer_object')
# GL/glext.h:7087
glGetActiveUniformBlockiv = _link_function('glGetActiveUniformBlockiv', None, [GLuint, GLuint, GLenum, POINTER(GLint)], 'ARB_uniform_buffer_object')
# GL/glext.h:7088
glGetActiveUniformBlockName = _link_function('glGetActiveUniformBlockName', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'ARB_uniform_buffer_object')
# GL/glext.h:7089
glUniformBlockBinding = _link_function('glUniformBlockBinding', None, [GLuint, GLuint, GLuint], 'ARB_uniform_buffer_object')
PFNGLGETUNIFORMINDICESPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLuint)) # GL/glext.h:7091
PFNGLGETACTIVEUNIFORMSIVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLuint), GLenum, POINTER(GLint)) # GL/glext.h:7092
PFNGLGETACTIVEUNIFORMNAMEPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7093
PFNGLGETUNIFORMBLOCKINDEXPROC = CFUNCTYPE(GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:7094
PFNGLGETACTIVEUNIFORMBLOCKIVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7095
PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7096
PFNGLUNIFORMBLOCKBINDINGPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:7097
# ARB_compatibility (GL/glext.h:7100)
GL_ARB_compatibility = 1 # GL/glext.h:7101
# ARB_copy_buffer (GL/glext.h:7104)
GL_ARB_copy_buffer = 1 # GL/glext.h:7105
# GL/glext.h:7107
glCopyBufferSubData = _link_function('glCopyBufferSubData', None, [GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr], 'ARB_copy_buffer')
PFNGLCOPYBUFFERSUBDATAPROC = CFUNCTYPE(None, GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr) # GL/glext.h:7109
# ARB_shader_texture_lod (GL/glext.h:7112)
GL_ARB_shader_texture_lod = 1 # GL/glext.h:7113
# ARB_depth_clamp (GL/glext.h:7116)
GL_ARB_depth_clamp = 1 # GL/glext.h:7117
# ARB_draw_elements_base_vertex (GL/glext.h:7120)
GL_ARB_draw_elements_base_vertex = 1 # GL/glext.h:7121
# GL/glext.h:7123
glDrawElementsBaseVertex = _link_function('glDrawElementsBaseVertex', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLint], 'ARB_draw_elements_base_vertex')
# GL/glext.h:7124
glDrawRangeElementsBaseVertex = _link_function('glDrawRangeElementsBaseVertex', None, [GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid), GLint], 'ARB_draw_elements_base_vertex')
# GL/glext.h:7125
glDrawElementsInstancedBaseVertex = _link_function('glDrawElementsInstancedBaseVertex', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei, GLint], 'ARB_draw_elements_base_vertex')
# GL/glext.h:7126
glMultiDrawElementsBaseVertex = _link_function('glMultiDrawElementsBaseVertex', None, [GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, POINTER(GLint)], 'ARB_draw_elements_base_vertex')
PFNGLDRAWELEMENTSBASEVERTEXPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLint) # GL/glext.h:7128
PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid), GLint) # GL/glext.h:7129
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei, GLint) # GL/glext.h:7130
PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC = CFUNCTYPE(None, GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, POINTER(GLint)) # GL/glext.h:7131
# ARB_fragment_coord_conventions (GL/glext.h:7134)
GL_ARB_fragment_coord_conventions = 1 # GL/glext.h:7135
# ARB_provoking_vertex (GL/glext.h:7138)
GL_ARB_provoking_vertex = 1 # GL/glext.h:7139
# GL/glext.h:7141
glProvokingVertex = _link_function('glProvokingVertex', None, [GLenum], 'ARB_provoking_vertex')
PFNGLPROVOKINGVERTEXPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7143
# ARB_seamless_cube_map (GL/glext.h:7146)
GL_ARB_seamless_cube_map = 1 # GL/glext.h:7147
# ARB_sync (GL/glext.h:7150)
GL_ARB_sync = 1 # GL/glext.h:7151
# GL/glext.h:7153
glFenceSync = _link_function('glFenceSync', GLsync, [GLenum, GLbitfield], 'ARB_sync')
# GL/glext.h:7154
glIsSync = _link_function('glIsSync', GLboolean, [GLsync], 'ARB_sync')
# GL/glext.h:7155
glDeleteSync = _link_function('glDeleteSync', None, [GLsync], 'ARB_sync')
# GL/glext.h:7156
glClientWaitSync = _link_function('glClientWaitSync', GLenum, [GLsync, GLbitfield, GLuint64], 'ARB_sync')
# GL/glext.h:7157
glWaitSync = _link_function('glWaitSync', None, [GLsync, GLbitfield, GLuint64], 'ARB_sync')
# GL/glext.h:7158
glGetInteger64v = _link_function('glGetInteger64v', None, [GLenum, POINTER(GLint64)], 'ARB_sync')
# GL/glext.h:7159
glGetSynciv = _link_function('glGetSynciv', None, [GLsync, GLenum, GLsizei, POINTER(GLsizei), POINTER(GLint)], 'ARB_sync')
PFNGLFENCESYNCPROC = CFUNCTYPE(GLsync, GLenum, GLbitfield) # GL/glext.h:7161
PFNGLISSYNCPROC = CFUNCTYPE(GLboolean, GLsync) # GL/glext.h:7162
PFNGLDELETESYNCPROC = CFUNCTYPE(None, GLsync) # GL/glext.h:7163
PFNGLCLIENTWAITSYNCPROC = CFUNCTYPE(GLenum, GLsync, GLbitfield, GLuint64) # GL/glext.h:7164
PFNGLWAITSYNCPROC = CFUNCTYPE(None, GLsync, GLbitfield, GLuint64) # GL/glext.h:7165
PFNGLGETINTEGER64VPROC = CFUNCTYPE(None, GLenum, POINTER(GLint64)) # GL/glext.h:7166
PFNGLGETSYNCIVPROC = CFUNCTYPE(None, GLsync, GLenum, GLsizei, POINTER(GLsizei), POINTER(GLint)) # GL/glext.h:7167
# ARB_texture_multisample (GL/glext.h:7170)
GL_ARB_texture_multisample = 1 # GL/glext.h:7171
# GL/glext.h:7173
glTexImage2DMultisample = _link_function('glTexImage2DMultisample', None, [GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean], 'ARB_texture_multisample')
# GL/glext.h:7174
glTexImage3DMultisample = _link_function('glTexImage3DMultisample', None, [GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], 'ARB_texture_multisample')
# GL/glext.h:7175
glGetMultisamplefv = _link_function('glGetMultisamplefv', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_texture_multisample')
# GL/glext.h:7176
glSampleMaski = _link_function('glSampleMaski', None, [GLuint, GLbitfield], 'ARB_texture_multisample')
PFNGLTEXIMAGE2DMULTISAMPLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean) # GL/glext.h:7178
PFNGLTEXIMAGE3DMULTISAMPLEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) # GL/glext.h:7179
PFNGLGETMULTISAMPLEFVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:7180
PFNGLSAMPLEMASKIPROC = CFUNCTYPE(None, GLuint, GLbitfield) # GL/glext.h:7181
# ARB_vertex_array_bgra (GL/glext.h:7184)
GL_ARB_vertex_array_bgra = 1 # GL/glext.h:7185
# ARB_draw_buffers_blend (GL/glext.h:7188)
GL_ARB_draw_buffers_blend = 1 # GL/glext.h:7189
# GL/glext.h:7191
glBlendEquationiARB = _link_function('glBlendEquationiARB', None, [GLuint, GLenum], 'ARB_draw_buffers_blend')
# GL/glext.h:7192
glBlendEquationSeparateiARB = _link_function('glBlendEquationSeparateiARB', None, [GLuint, GLenum, GLenum], 'ARB_draw_buffers_blend')
# GL/glext.h:7193
glBlendFunciARB = _link_function('glBlendFunciARB', None, [GLuint, GLenum, GLenum], 'ARB_draw_buffers_blend')
# GL/glext.h:7194
glBlendFuncSeparateiARB = _link_function('glBlendFuncSeparateiARB', None, [GLuint, GLenum, GLenum, GLenum, GLenum], 'ARB_draw_buffers_blend')
PFNGLBLENDEQUATIONIARBPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:7196
PFNGLBLENDEQUATIONSEPARATEIARBPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:7197
PFNGLBLENDFUNCIARBPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:7198
PFNGLBLENDFUNCSEPARATEIARBPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:7199
# ARB_sample_shading (GL/glext.h:7202)
GL_ARB_sample_shading = 1 # GL/glext.h:7203
# GL/glext.h:7205
glMinSampleShadingARB = _link_function('glMinSampleShadingARB', None, [GLfloat], 'ARB_sample_shading')
PFNGLMINSAMPLESHADINGARBPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:7207
# ARB_texture_cube_map_array (GL/glext.h:7210)
GL_ARB_texture_cube_map_array = 1 # GL/glext.h:7211
# ARB_texture_gather (GL/glext.h:7214)
GL_ARB_texture_gather = 1 # GL/glext.h:7215
# ARB_texture_query_lod (GL/glext.h:7218)
GL_ARB_texture_query_lod = 1 # GL/glext.h:7219
# ARB_shading_language_include (GL/glext.h:7222)
GL_ARB_shading_language_include = 1 # GL/glext.h:7223
# GL/glext.h:7225
glNamedStringARB = _link_function('glNamedStringARB', None, [GLenum, GLint, POINTER(GLchar), GLint, POINTER(GLchar)], 'ARB_shading_language_include')
# GL/glext.h:7226
glDeleteNamedStringARB = _link_function('glDeleteNamedStringARB', None, [GLint, POINTER(GLchar)], 'ARB_shading_language_include')
# GL/glext.h:7227
glCompileShaderIncludeARB = _link_function('glCompileShaderIncludeARB', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)], 'ARB_shading_language_include')
# GL/glext.h:7228
glIsNamedStringARB = _link_function('glIsNamedStringARB', GLboolean, [GLint, POINTER(GLchar)], 'ARB_shading_language_include')
# GL/glext.h:7229
glGetNamedStringARB = _link_function('glGetNamedStringARB', None, [GLint, POINTER(GLchar), GLsizei, POINTER(GLint), POINTER(GLchar)], 'ARB_shading_language_include')
# GL/glext.h:7230
glGetNamedStringivARB = _link_function('glGetNamedStringivARB', None, [GLint, POINTER(GLchar), GLenum, POINTER(GLint)], 'ARB_shading_language_include')
PFNGLNAMEDSTRINGARBPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLchar), GLint, POINTER(GLchar)) # GL/glext.h:7232
PFNGLDELETENAMEDSTRINGARBPROC = CFUNCTYPE(None, GLint, POINTER(GLchar)) # GL/glext.h:7233
PFNGLCOMPILESHADERINCLUDEARBPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), POINTER(GLint)) # GL/glext.h:7234
PFNGLISNAMEDSTRINGARBPROC = CFUNCTYPE(GLboolean, GLint, POINTER(GLchar)) # GL/glext.h:7235
PFNGLGETNAMEDSTRINGARBPROC = CFUNCTYPE(None, GLint, POINTER(GLchar), GLsizei, POINTER(GLint), POINTER(GLchar)) # GL/glext.h:7236
PFNGLGETNAMEDSTRINGIVARBPROC = CFUNCTYPE(None, GLint, POINTER(GLchar), GLenum, POINTER(GLint)) # GL/glext.h:7237
# ARB_texture_compression_bptc (GL/glext.h:7240)
GL_ARB_texture_compression_bptc = 1 # GL/glext.h:7241
# ARB_blend_func_extended (GL/glext.h:7244)
GL_ARB_blend_func_extended = 1 # GL/glext.h:7245
# GL/glext.h:7247
glBindFragDataLocationIndexed = _link_function('glBindFragDataLocationIndexed', None, [GLuint, GLuint, GLuint, POINTER(GLchar)], 'ARB_blend_func_extended')
# GL/glext.h:7248
glGetFragDataIndex = _link_function('glGetFragDataIndex', GLint, [GLuint, POINTER(GLchar)], 'ARB_blend_func_extended')
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:7250
PFNGLGETFRAGDATAINDEXPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:7251
# ARB_explicit_attrib_location (GL/glext.h:7254)
GL_ARB_explicit_attrib_location = 1 # GL/glext.h:7255
# ARB_occlusion_query2 (GL/glext.h:7258)
GL_ARB_occlusion_query2 = 1 # GL/glext.h:7259
# ARB_sampler_objects (GL/glext.h:7262)
GL_ARB_sampler_objects = 1 # GL/glext.h:7263
# GL/glext.h:7265
glGenSamplers = _link_function('glGenSamplers', None, [GLsizei, POINTER(GLuint)], 'ARB_sampler_objects')
# GL/glext.h:7266
glDeleteSamplers = _link_function('glDeleteSamplers', None, [GLsizei, POINTER(GLuint)], 'ARB_sampler_objects')
# GL/glext.h:7267
glIsSampler = _link_function('glIsSampler', GLboolean, [GLuint], 'ARB_sampler_objects')
# GL/glext.h:7268
glBindSampler = _link_function('glBindSampler', None, [GLuint, GLuint], 'ARB_sampler_objects')
# GL/glext.h:7269
glSamplerParameteri = _link_function('glSamplerParameteri', None, [GLuint, GLenum, GLint], 'ARB_sampler_objects')
# GL/glext.h:7270
glSamplerParameteriv = _link_function('glSamplerParameteriv', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_sampler_objects')
# GL/glext.h:7271
glSamplerParameterf = _link_function('glSamplerParameterf', None, [GLuint, GLenum, GLfloat], 'ARB_sampler_objects')
# GL/glext.h:7272
glSamplerParameterfv = _link_function('glSamplerParameterfv', None, [GLuint, GLenum, POINTER(GLfloat)], 'ARB_sampler_objects')
# GL/glext.h:7273
glSamplerParameterIiv = _link_function('glSamplerParameterIiv', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_sampler_objects')
# GL/glext.h:7274
glSamplerParameterIuiv = _link_function('glSamplerParameterIuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'ARB_sampler_objects')
# GL/glext.h:7275
glGetSamplerParameteriv = _link_function('glGetSamplerParameteriv', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_sampler_objects')
# GL/glext.h:7276
glGetSamplerParameterIiv = _link_function('glGetSamplerParameterIiv', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_sampler_objects')
# GL/glext.h:7277
glGetSamplerParameterfv = _link_function('glGetSamplerParameterfv', None, [GLuint, GLenum, POINTER(GLfloat)], 'ARB_sampler_objects')
# GL/glext.h:7278
glGetSamplerParameterIuiv = _link_function('glGetSamplerParameterIuiv', None, [GLuint, GLenum, POINTER(GLuint)], 'ARB_sampler_objects')
PFNGLGENSAMPLERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7280
PFNGLDELETESAMPLERSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7281
PFNGLISSAMPLERPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7282
PFNGLBINDSAMPLERPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:7283
PFNGLSAMPLERPARAMETERIPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:7284
PFNGLSAMPLERPARAMETERIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7285
PFNGLSAMPLERPARAMETERFPROC = CFUNCTYPE(None, GLuint, GLenum, GLfloat) # GL/glext.h:7286
PFNGLSAMPLERPARAMETERFVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7287
PFNGLSAMPLERPARAMETERIIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7288
PFNGLSAMPLERPARAMETERIUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:7289
PFNGLGETSAMPLERPARAMETERIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7290
PFNGLGETSAMPLERPARAMETERIIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7291
PFNGLGETSAMPLERPARAMETERFVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:7292
PFNGLGETSAMPLERPARAMETERIUIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:7293
# ARB_shader_bit_encoding (GL/glext.h:7296)
GL_ARB_shader_bit_encoding = 1 # GL/glext.h:7297
# ARB_texture_rgb10_a2ui (GL/glext.h:7300)
GL_ARB_texture_rgb10_a2ui = 1 # GL/glext.h:7301
# ARB_texture_swizzle (GL/glext.h:7304)
GL_ARB_texture_swizzle = 1 # GL/glext.h:7305
# ARB_timer_query (GL/glext.h:7308)
GL_ARB_timer_query = 1 # GL/glext.h:7309
# GL/glext.h:7311
glQueryCounter = _link_function('glQueryCounter', None, [GLuint, GLenum], 'ARB_timer_query')
# GL/glext.h:7312
glGetQueryObjecti64v = _link_function('glGetQueryObjecti64v', None, [GLuint, GLenum, POINTER(GLint64)], 'ARB_timer_query')
# GL/glext.h:7313
glGetQueryObjectui64v = _link_function('glGetQueryObjectui64v', None, [GLuint, GLenum, POINTER(GLuint64)], 'ARB_timer_query')
PFNGLQUERYCOUNTERPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:7315
PFNGLGETQUERYOBJECTI64VPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64)) # GL/glext.h:7316
PFNGLGETQUERYOBJECTUI64VPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64)) # GL/glext.h:7317
# ARB_vertex_type_2_10_10_10_rev (GL/glext.h:7320)
GL_ARB_vertex_type_2_10_10_10_rev = 1 # GL/glext.h:7321
# GL/glext.h:7323
glVertexP2ui = _link_function('glVertexP2ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7324
glVertexP2uiv = _link_function('glVertexP2uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7325
glVertexP3ui = _link_function('glVertexP3ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7326
glVertexP3uiv = _link_function('glVertexP3uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7327
glVertexP4ui = _link_function('glVertexP4ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7328
glVertexP4uiv = _link_function('glVertexP4uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7329
glTexCoordP1ui = _link_function('glTexCoordP1ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7330
glTexCoordP1uiv = _link_function('glTexCoordP1uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7331
glTexCoordP2ui = _link_function('glTexCoordP2ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7332
glTexCoordP2uiv = _link_function('glTexCoordP2uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7333
glTexCoordP3ui = _link_function('glTexCoordP3ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7334
glTexCoordP3uiv = _link_function('glTexCoordP3uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7335
glTexCoordP4ui = _link_function('glTexCoordP4ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7336
glTexCoordP4uiv = _link_function('glTexCoordP4uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7337
glMultiTexCoordP1ui = _link_function('glMultiTexCoordP1ui', None, [GLenum, GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7338
glMultiTexCoordP1uiv = _link_function('glMultiTexCoordP1uiv', None, [GLenum, GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7339
glMultiTexCoordP2ui = _link_function('glMultiTexCoordP2ui', None, [GLenum, GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7340
glMultiTexCoordP2uiv = _link_function('glMultiTexCoordP2uiv', None, [GLenum, GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7341
glMultiTexCoordP3ui = _link_function('glMultiTexCoordP3ui', None, [GLenum, GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7342
glMultiTexCoordP3uiv = _link_function('glMultiTexCoordP3uiv', None, [GLenum, GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7343
glMultiTexCoordP4ui = _link_function('glMultiTexCoordP4ui', None, [GLenum, GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7344
glMultiTexCoordP4uiv = _link_function('glMultiTexCoordP4uiv', None, [GLenum, GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7345
glNormalP3ui = _link_function('glNormalP3ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7346
glNormalP3uiv = _link_function('glNormalP3uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7347
glColorP3ui = _link_function('glColorP3ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7348
glColorP3uiv = _link_function('glColorP3uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7349
glColorP4ui = _link_function('glColorP4ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7350
glColorP4uiv = _link_function('glColorP4uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7351
glSecondaryColorP3ui = _link_function('glSecondaryColorP3ui', None, [GLenum, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7352
glSecondaryColorP3uiv = _link_function('glSecondaryColorP3uiv', None, [GLenum, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7353
glVertexAttribP1ui = _link_function('glVertexAttribP1ui', None, [GLuint, GLenum, GLboolean, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7354
glVertexAttribP1uiv = _link_function('glVertexAttribP1uiv', None, [GLuint, GLenum, GLboolean, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7355
glVertexAttribP2ui = _link_function('glVertexAttribP2ui', None, [GLuint, GLenum, GLboolean, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7356
glVertexAttribP2uiv = _link_function('glVertexAttribP2uiv', None, [GLuint, GLenum, GLboolean, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7357
glVertexAttribP3ui = _link_function('glVertexAttribP3ui', None, [GLuint, GLenum, GLboolean, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7358
glVertexAttribP3uiv = _link_function('glVertexAttribP3uiv', None, [GLuint, GLenum, GLboolean, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7359
glVertexAttribP4ui = _link_function('glVertexAttribP4ui', None, [GLuint, GLenum, GLboolean, GLuint], 'ARB_vertex_type_2_10_10_10_rev')
# GL/glext.h:7360
glVertexAttribP4uiv = _link_function('glVertexAttribP4uiv', None, [GLuint, GLenum, GLboolean, POINTER(GLuint)], 'ARB_vertex_type_2_10_10_10_rev')
PFNGLVERTEXP2UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7362
PFNGLVERTEXP2UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7363
PFNGLVERTEXP3UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7364
PFNGLVERTEXP3UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7365
PFNGLVERTEXP4UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7366
PFNGLVERTEXP4UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7367
PFNGLTEXCOORDP1UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7368
PFNGLTEXCOORDP1UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7369
PFNGLTEXCOORDP2UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7370
PFNGLTEXCOORDP2UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7371
PFNGLTEXCOORDP3UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7372
PFNGLTEXCOORDP3UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7373
PFNGLTEXCOORDP4UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7374
PFNGLTEXCOORDP4UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7375
PFNGLMULTITEXCOORDP1UIPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7376
PFNGLMULTITEXCOORDP1UIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7377
PFNGLMULTITEXCOORDP2UIPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7378
PFNGLMULTITEXCOORDP2UIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7379
PFNGLMULTITEXCOORDP3UIPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7380
PFNGLMULTITEXCOORDP3UIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7381
PFNGLMULTITEXCOORDP4UIPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:7382
PFNGLMULTITEXCOORDP4UIVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:7383
PFNGLNORMALP3UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7384
PFNGLNORMALP3UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7385
PFNGLCOLORP3UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7386
PFNGLCOLORP3UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7387
PFNGLCOLORP4UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7388
PFNGLCOLORP4UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7389
PFNGLSECONDARYCOLORP3UIPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7390
PFNGLSECONDARYCOLORP3UIVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint)) # GL/glext.h:7391
PFNGLVERTEXATTRIBP1UIPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, GLuint) # GL/glext.h:7392
PFNGLVERTEXATTRIBP1UIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, POINTER(GLuint)) # GL/glext.h:7393
PFNGLVERTEXATTRIBP2UIPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, GLuint) # GL/glext.h:7394
PFNGLVERTEXATTRIBP2UIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, POINTER(GLuint)) # GL/glext.h:7395
PFNGLVERTEXATTRIBP3UIPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, GLuint) # GL/glext.h:7396
PFNGLVERTEXATTRIBP3UIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, POINTER(GLuint)) # GL/glext.h:7397
PFNGLVERTEXATTRIBP4UIPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, GLuint) # GL/glext.h:7398
PFNGLVERTEXATTRIBP4UIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLboolean, POINTER(GLuint)) # GL/glext.h:7399
# ARB_draw_indirect (GL/glext.h:7402)
GL_ARB_draw_indirect = 1 # GL/glext.h:7403
# GL/glext.h:7405
glDrawArraysIndirect = _link_function('glDrawArraysIndirect', None, [GLenum, POINTER(GLvoid)], 'ARB_draw_indirect')
# GL/glext.h:7406
glDrawElementsIndirect = _link_function('glDrawElementsIndirect', None, [GLenum, GLenum, POINTER(GLvoid)], 'ARB_draw_indirect')
PFNGLDRAWARRAYSINDIRECTPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:7408
PFNGLDRAWELEMENTSINDIRECTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7409
# ARB_gpu_shader5 (GL/glext.h:7412)
GL_ARB_gpu_shader5 = 1 # GL/glext.h:7413
# ARB_gpu_shader_fp64 (GL/glext.h:7416)
GL_ARB_gpu_shader_fp64 = 1 # GL/glext.h:7417
# GL/glext.h:7419
glUniform1d = _link_function('glUniform1d', None, [GLint, GLdouble], 'ARB_gpu_shader_fp64')
# GL/glext.h:7420
glUniform2d = _link_function('glUniform2d', None, [GLint, GLdouble, GLdouble], 'ARB_gpu_shader_fp64')
# GL/glext.h:7421
glUniform3d = _link_function('glUniform3d', None, [GLint, GLdouble, GLdouble, GLdouble], 'ARB_gpu_shader_fp64')
# GL/glext.h:7422
glUniform4d = _link_function('glUniform4d', None, [GLint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_gpu_shader_fp64')
# GL/glext.h:7423
glUniform1dv = _link_function('glUniform1dv', None, [GLint, GLsizei, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7424
glUniform2dv = _link_function('glUniform2dv', None, [GLint, GLsizei, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7425
glUniform3dv = _link_function('glUniform3dv', None, [GLint, GLsizei, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7426
glUniform4dv = _link_function('glUniform4dv', None, [GLint, GLsizei, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7427
glUniformMatrix2dv = _link_function('glUniformMatrix2dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7428
glUniformMatrix3dv = _link_function('glUniformMatrix3dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7429
glUniformMatrix4dv = _link_function('glUniformMatrix4dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7430
glUniformMatrix2x3dv = _link_function('glUniformMatrix2x3dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7431
glUniformMatrix2x4dv = _link_function('glUniformMatrix2x4dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7432
glUniformMatrix3x2dv = _link_function('glUniformMatrix3x2dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7433
glUniformMatrix3x4dv = _link_function('glUniformMatrix3x4dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7434
glUniformMatrix4x2dv = _link_function('glUniformMatrix4x2dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7435
glUniformMatrix4x3dv = _link_function('glUniformMatrix4x3dv', None, [GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
# GL/glext.h:7436
glGetUniformdv = _link_function('glGetUniformdv', None, [GLuint, GLint, POINTER(GLdouble)], 'ARB_gpu_shader_fp64')
PFNGLUNIFORM1DPROC = CFUNCTYPE(None, GLint, GLdouble) # GL/glext.h:7438
PFNGLUNIFORM2DPROC = CFUNCTYPE(None, GLint, GLdouble, GLdouble) # GL/glext.h:7439
PFNGLUNIFORM3DPROC = CFUNCTYPE(None, GLint, GLdouble, GLdouble, GLdouble) # GL/glext.h:7440
PFNGLUNIFORM4DPROC = CFUNCTYPE(None, GLint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:7441
PFNGLUNIFORM1DVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7442
PFNGLUNIFORM2DVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7443
PFNGLUNIFORM3DVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7444
PFNGLUNIFORM4DVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7445
PFNGLUNIFORMMATRIX2DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7446
PFNGLUNIFORMMATRIX3DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7447
PFNGLUNIFORMMATRIX4DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7448
PFNGLUNIFORMMATRIX2X3DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7449
PFNGLUNIFORMMATRIX2X4DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7450
PFNGLUNIFORMMATRIX3X2DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7451
PFNGLUNIFORMMATRIX3X4DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7452
PFNGLUNIFORMMATRIX4X2DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7453
PFNGLUNIFORMMATRIX4X3DVPROC = CFUNCTYPE(None, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7454
PFNGLGETUNIFORMDVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLdouble)) # GL/glext.h:7455
# ARB_shader_subroutine (GL/glext.h:7458)
GL_ARB_shader_subroutine = 1 # GL/glext.h:7459
# GL/glext.h:7461
glGetSubroutineUniformLocation = _link_function('glGetSubroutineUniformLocation', GLint, [GLuint, GLenum, POINTER(GLchar)], 'ARB_shader_subroutine')
# GL/glext.h:7462
glGetSubroutineIndex = _link_function('glGetSubroutineIndex', GLuint, [GLuint, GLenum, POINTER(GLchar)], 'ARB_shader_subroutine')
# GL/glext.h:7463
glGetActiveSubroutineUniformiv = _link_function('glGetActiveSubroutineUniformiv', None, [GLuint, GLenum, GLuint, GLenum, POINTER(GLint)], 'ARB_shader_subroutine')
# GL/glext.h:7464
glGetActiveSubroutineUniformName = _link_function('glGetActiveSubroutineUniformName', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'ARB_shader_subroutine')
# GL/glext.h:7465
glGetActiveSubroutineName = _link_function('glGetActiveSubroutineName', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'ARB_shader_subroutine')
# GL/glext.h:7466
glUniformSubroutinesuiv = _link_function('glUniformSubroutinesuiv', None, [GLenum, GLsizei, POINTER(GLuint)], 'ARB_shader_subroutine')
# GL/glext.h:7467
glGetUniformSubroutineuiv = _link_function('glGetUniformSubroutineuiv', None, [GLenum, GLint, POINTER(GLuint)], 'ARB_shader_subroutine')
# GL/glext.h:7468
glGetProgramStageiv = _link_function('glGetProgramStageiv', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'ARB_shader_subroutine')
PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC = CFUNCTYPE(GLint, GLuint, GLenum, POINTER(GLchar)) # GL/glext.h:7470
PFNGLGETSUBROUTINEINDEXPROC = CFUNCTYPE(GLuint, GLuint, GLenum, POINTER(GLchar)) # GL/glext.h:7471
PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7472
PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7473
PFNGLGETACTIVESUBROUTINENAMEPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7474
PFNGLUNIFORMSUBROUTINESUIVPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLuint)) # GL/glext.h:7475
PFNGLGETUNIFORMSUBROUTINEUIVPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(GLuint)) # GL/glext.h:7476
PFNGLGETPROGRAMSTAGEIVPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7477
# ARB_tessellation_shader (GL/glext.h:7480)
GL_ARB_tessellation_shader = 1 # GL/glext.h:7481
# GL/glext.h:7483
glPatchParameteri = _link_function('glPatchParameteri', None, [GLenum, GLint], 'ARB_tessellation_shader')
# GL/glext.h:7484
glPatchParameterfv = _link_function('glPatchParameterfv', None, [GLenum, POINTER(GLfloat)], 'ARB_tessellation_shader')
PFNGLPATCHPARAMETERIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:7486
PFNGLPATCHPARAMETERFVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:7487
# ARB_texture_buffer_object_rgb32 (GL/glext.h:7490)
GL_ARB_texture_buffer_object_rgb32 = 1 # GL/glext.h:7491
# ARB_transform_feedback2 (GL/glext.h:7494)
GL_ARB_transform_feedback2 = 1 # GL/glext.h:7495
# GL/glext.h:7497
glBindTransformFeedback = _link_function('glBindTransformFeedback', None, [GLenum, GLuint], 'ARB_transform_feedback2')
# GL/glext.h:7498
glDeleteTransformFeedbacks = _link_function('glDeleteTransformFeedbacks', None, [GLsizei, POINTER(GLuint)], 'ARB_transform_feedback2')
# GL/glext.h:7499
glGenTransformFeedbacks = _link_function('glGenTransformFeedbacks', None, [GLsizei, POINTER(GLuint)], 'ARB_transform_feedback2')
# GL/glext.h:7500
glIsTransformFeedback = _link_function('glIsTransformFeedback', GLboolean, [GLuint], 'ARB_transform_feedback2')
# GL/glext.h:7501
glPauseTransformFeedback = _link_function('glPauseTransformFeedback', None, [], 'ARB_transform_feedback2')
# GL/glext.h:7502
glResumeTransformFeedback = _link_function('glResumeTransformFeedback', None, [], 'ARB_transform_feedback2')
# GL/glext.h:7503
glDrawTransformFeedback = _link_function('glDrawTransformFeedback', None, [GLenum, GLuint], 'ARB_transform_feedback2')
PFNGLBINDTRANSFORMFEEDBACKPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7505
PFNGLDELETETRANSFORMFEEDBACKSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7506
PFNGLGENTRANSFORMFEEDBACKSPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7507
PFNGLISTRANSFORMFEEDBACKPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7508
PFNGLPAUSETRANSFORMFEEDBACKPROC = CFUNCTYPE(None) # GL/glext.h:7509
PFNGLRESUMETRANSFORMFEEDBACKPROC = CFUNCTYPE(None) # GL/glext.h:7510
PFNGLDRAWTRANSFORMFEEDBACKPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7511
# ARB_transform_feedback3 (GL/glext.h:7514)
GL_ARB_transform_feedback3 = 1 # GL/glext.h:7515
# GL/glext.h:7517
glDrawTransformFeedbackStream = _link_function('glDrawTransformFeedbackStream', None, [GLenum, GLuint, GLuint], 'ARB_transform_feedback3')
# GL/glext.h:7518
glBeginQueryIndexed = _link_function('glBeginQueryIndexed', None, [GLenum, GLuint, GLuint], 'ARB_transform_feedback3')
# GL/glext.h:7519
glEndQueryIndexed = _link_function('glEndQueryIndexed', None, [GLenum, GLuint], 'ARB_transform_feedback3')
# GL/glext.h:7520
glGetQueryIndexediv = _link_function('glGetQueryIndexediv', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'ARB_transform_feedback3')
PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:7522
PFNGLBEGINQUERYINDEXEDPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:7523
PFNGLENDQUERYINDEXEDPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:7524
PFNGLGETQUERYINDEXEDIVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7525
# ARB_ES2_compatibility (GL/glext.h:7528)
GL_ARB_ES2_compatibility = 1 # GL/glext.h:7529
# GL/glext.h:7531
glReleaseShaderCompiler = _link_function('glReleaseShaderCompiler', None, [], 'ARB_ES2_compatibility')
# GL/glext.h:7532
glShaderBinary = _link_function('glShaderBinary', None, [GLsizei, POINTER(GLuint), GLenum, POINTER(GLvoid), GLsizei], 'ARB_ES2_compatibility')
# GL/glext.h:7533
glGetShaderPrecisionFormat = _link_function('glGetShaderPrecisionFormat', None, [GLenum, GLenum, POINTER(GLint), POINTER(GLint)], 'ARB_ES2_compatibility')
# GL/glext.h:7534
glDepthRangef = _link_function('glDepthRangef', None, [GLfloat, GLfloat], 'ARB_ES2_compatibility')
# GL/glext.h:7535
glClearDepthf = _link_function('glClearDepthf', None, [GLfloat], 'ARB_ES2_compatibility')
PFNGLRELEASESHADERCOMPILERPROC = CFUNCTYPE(None) # GL/glext.h:7537
PFNGLSHADERBINARYPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint), GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:7538
PFNGLGETSHADERPRECISIONFORMATPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint), POINTER(GLint)) # GL/glext.h:7539
PFNGLDEPTHRANGEFPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:7540
PFNGLCLEARDEPTHFPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:7541
# ARB_get_program_binary (GL/glext.h:7544)
GL_ARB_get_program_binary = 1 # GL/glext.h:7545
# GL/glext.h:7547
glGetProgramBinary = _link_function('glGetProgramBinary', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLenum), POINTER(GLvoid)], 'ARB_get_program_binary')
# GL/glext.h:7548
glProgramBinary = _link_function('glProgramBinary', None, [GLuint, GLenum, POINTER(GLvoid), GLsizei], 'ARB_get_program_binary')
# GL/glext.h:7549
glProgramParameteri = _link_function('glProgramParameteri', None, [GLuint, GLenum, GLint], 'ARB_get_program_binary')
PFNGLGETPROGRAMBINARYPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLenum), POINTER(GLvoid)) # GL/glext.h:7551
PFNGLPROGRAMBINARYPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:7552
PFNGLPROGRAMPARAMETERIPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:7553
# ARB_separate_shader_objects (GL/glext.h:7556)
GL_ARB_separate_shader_objects = 1 # GL/glext.h:7557
# GL/glext.h:7559
glUseProgramStages = _link_function('glUseProgramStages', None, [GLuint, GLbitfield, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7560
glActiveShaderProgram = _link_function('glActiveShaderProgram', None, [GLuint, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7561
glCreateShaderProgramv = _link_function('glCreateShaderProgramv', GLuint, [GLenum, GLsizei, POINTER(POINTER(GLchar))], 'ARB_separate_shader_objects')
# GL/glext.h:7562
glBindProgramPipeline = _link_function('glBindProgramPipeline', None, [GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7563
glDeleteProgramPipelines = _link_function('glDeleteProgramPipelines', None, [GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7564
glGenProgramPipelines = _link_function('glGenProgramPipelines', None, [GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7565
glIsProgramPipeline = _link_function('glIsProgramPipeline', GLboolean, [GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7566
glGetProgramPipelineiv = _link_function('glGetProgramPipelineiv', None, [GLuint, GLenum, POINTER(GLint)], 'ARB_separate_shader_objects')
# GL/glext.h:7567
glProgramUniform1i = _link_function('glProgramUniform1i', None, [GLuint, GLint, GLint], 'ARB_separate_shader_objects')
# GL/glext.h:7568
glProgramUniform1iv = _link_function('glProgramUniform1iv', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'ARB_separate_shader_objects')
# GL/glext.h:7569
glProgramUniform1f = _link_function('glProgramUniform1f', None, [GLuint, GLint, GLfloat], 'ARB_separate_shader_objects')
# GL/glext.h:7570
glProgramUniform1fv = _link_function('glProgramUniform1fv', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7571
glProgramUniform1d = _link_function('glProgramUniform1d', None, [GLuint, GLint, GLdouble], 'ARB_separate_shader_objects')
# GL/glext.h:7572
glProgramUniform1dv = _link_function('glProgramUniform1dv', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7573
glProgramUniform1ui = _link_function('glProgramUniform1ui', None, [GLuint, GLint, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7574
glProgramUniform1uiv = _link_function('glProgramUniform1uiv', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7575
glProgramUniform2i = _link_function('glProgramUniform2i', None, [GLuint, GLint, GLint, GLint], 'ARB_separate_shader_objects')
# GL/glext.h:7576
glProgramUniform2iv = _link_function('glProgramUniform2iv', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'ARB_separate_shader_objects')
# GL/glext.h:7577
glProgramUniform2f = _link_function('glProgramUniform2f', None, [GLuint, GLint, GLfloat, GLfloat], 'ARB_separate_shader_objects')
# GL/glext.h:7578
glProgramUniform2fv = _link_function('glProgramUniform2fv', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7579
glProgramUniform2d = _link_function('glProgramUniform2d', None, [GLuint, GLint, GLdouble, GLdouble], 'ARB_separate_shader_objects')
# GL/glext.h:7580
glProgramUniform2dv = _link_function('glProgramUniform2dv', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7581
glProgramUniform2ui = _link_function('glProgramUniform2ui', None, [GLuint, GLint, GLuint, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7582
glProgramUniform2uiv = _link_function('glProgramUniform2uiv', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7583
glProgramUniform3i = _link_function('glProgramUniform3i', None, [GLuint, GLint, GLint, GLint, GLint], 'ARB_separate_shader_objects')
# GL/glext.h:7584
glProgramUniform3iv = _link_function('glProgramUniform3iv', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'ARB_separate_shader_objects')
# GL/glext.h:7585
glProgramUniform3f = _link_function('glProgramUniform3f', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat], 'ARB_separate_shader_objects')
# GL/glext.h:7586
glProgramUniform3fv = _link_function('glProgramUniform3fv', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7587
glProgramUniform3d = _link_function('glProgramUniform3d', None, [GLuint, GLint, GLdouble, GLdouble, GLdouble], 'ARB_separate_shader_objects')
# GL/glext.h:7588
glProgramUniform3dv = _link_function('glProgramUniform3dv', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7589
glProgramUniform3ui = _link_function('glProgramUniform3ui', None, [GLuint, GLint, GLuint, GLuint, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7590
glProgramUniform3uiv = _link_function('glProgramUniform3uiv', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7591
glProgramUniform4i = _link_function('glProgramUniform4i', None, [GLuint, GLint, GLint, GLint, GLint, GLint], 'ARB_separate_shader_objects')
# GL/glext.h:7592
glProgramUniform4iv = _link_function('glProgramUniform4iv', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'ARB_separate_shader_objects')
# GL/glext.h:7593
glProgramUniform4f = _link_function('glProgramUniform4f', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_separate_shader_objects')
# GL/glext.h:7594
glProgramUniform4fv = _link_function('glProgramUniform4fv', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7595
glProgramUniform4d = _link_function('glProgramUniform4d', None, [GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_separate_shader_objects')
# GL/glext.h:7596
glProgramUniform4dv = _link_function('glProgramUniform4dv', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7597
glProgramUniform4ui = _link_function('glProgramUniform4ui', None, [GLuint, GLint, GLuint, GLuint, GLuint, GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7598
glProgramUniform4uiv = _link_function('glProgramUniform4uiv', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'ARB_separate_shader_objects')
# GL/glext.h:7599
glProgramUniformMatrix2fv = _link_function('glProgramUniformMatrix2fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7600
glProgramUniformMatrix3fv = _link_function('glProgramUniformMatrix3fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7601
glProgramUniformMatrix4fv = _link_function('glProgramUniformMatrix4fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7602
glProgramUniformMatrix2dv = _link_function('glProgramUniformMatrix2dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7603
glProgramUniformMatrix3dv = _link_function('glProgramUniformMatrix3dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7604
glProgramUniformMatrix4dv = _link_function('glProgramUniformMatrix4dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7605
glProgramUniformMatrix2x3fv = _link_function('glProgramUniformMatrix2x3fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7606
glProgramUniformMatrix3x2fv = _link_function('glProgramUniformMatrix3x2fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7607
glProgramUniformMatrix2x4fv = _link_function('glProgramUniformMatrix2x4fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7608
glProgramUniformMatrix4x2fv = _link_function('glProgramUniformMatrix4x2fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7609
glProgramUniformMatrix3x4fv = _link_function('glProgramUniformMatrix3x4fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7610
glProgramUniformMatrix4x3fv = _link_function('glProgramUniformMatrix4x3fv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'ARB_separate_shader_objects')
# GL/glext.h:7611
glProgramUniformMatrix2x3dv = _link_function('glProgramUniformMatrix2x3dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7612
glProgramUniformMatrix3x2dv = _link_function('glProgramUniformMatrix3x2dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7613
glProgramUniformMatrix2x4dv = _link_function('glProgramUniformMatrix2x4dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7614
glProgramUniformMatrix4x2dv = _link_function('glProgramUniformMatrix4x2dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7615
glProgramUniformMatrix3x4dv = _link_function('glProgramUniformMatrix3x4dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7616
glProgramUniformMatrix4x3dv = _link_function('glProgramUniformMatrix4x3dv', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'ARB_separate_shader_objects')
# GL/glext.h:7617
glValidateProgramPipeline = _link_function('glValidateProgramPipeline', None, [GLuint], 'ARB_separate_shader_objects')
# GL/glext.h:7618
glGetProgramPipelineInfoLog = _link_function('glGetProgramPipelineInfoLog', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'ARB_separate_shader_objects')
PFNGLUSEPROGRAMSTAGESPROC = CFUNCTYPE(None, GLuint, GLbitfield, GLuint) # GL/glext.h:7620
PFNGLACTIVESHADERPROGRAMPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:7621
PFNGLCREATESHADERPROGRAMVPROC = CFUNCTYPE(GLuint, GLenum, GLsizei, POINTER(POINTER(GLchar))) # GL/glext.h:7622
PFNGLBINDPROGRAMPIPELINEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7623
PFNGLDELETEPROGRAMPIPELINESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7624
PFNGLGENPROGRAMPIPELINESPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:7625
PFNGLISPROGRAMPIPELINEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:7626
PFNGLGETPROGRAMPIPELINEIVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7627
PFNGLPROGRAMUNIFORM1IPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:7628
PFNGLPROGRAMUNIFORM1IVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:7629
PFNGLPROGRAMUNIFORM1FPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat) # GL/glext.h:7630
PFNGLPROGRAMUNIFORM1FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7631
PFNGLPROGRAMUNIFORM1DPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble) # GL/glext.h:7632
PFNGLPROGRAMUNIFORM1DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7633
PFNGLPROGRAMUNIFORM1UIPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:7634
PFNGLPROGRAMUNIFORM1UIVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7635
PFNGLPROGRAMUNIFORM2IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:7636
PFNGLPROGRAMUNIFORM2IVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:7637
PFNGLPROGRAMUNIFORM2FPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat) # GL/glext.h:7638
PFNGLPROGRAMUNIFORM2FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7639
PFNGLPROGRAMUNIFORM2DPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble) # GL/glext.h:7640
PFNGLPROGRAMUNIFORM2DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7641
PFNGLPROGRAMUNIFORM2UIPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint) # GL/glext.h:7642
PFNGLPROGRAMUNIFORM2UIVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7643
PFNGLPROGRAMUNIFORM3IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:7644
PFNGLPROGRAMUNIFORM3IVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:7645
PFNGLPROGRAMUNIFORM3FPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:7646
PFNGLPROGRAMUNIFORM3FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7647
PFNGLPROGRAMUNIFORM3DPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble, GLdouble) # GL/glext.h:7648
PFNGLPROGRAMUNIFORM3DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7649
PFNGLPROGRAMUNIFORM3UIPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint) # GL/glext.h:7650
PFNGLPROGRAMUNIFORM3UIVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7651
PFNGLPROGRAMUNIFORM4IPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:7652
PFNGLPROGRAMUNIFORM4IVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:7653
PFNGLPROGRAMUNIFORM4FPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:7654
PFNGLPROGRAMUNIFORM4FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7655
PFNGLPROGRAMUNIFORM4DPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:7656
PFNGLPROGRAMUNIFORM4DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7657
PFNGLPROGRAMUNIFORM4UIPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:7658
PFNGLPROGRAMUNIFORM4UIVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7659
PFNGLPROGRAMUNIFORMMATRIX2FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7660
PFNGLPROGRAMUNIFORMMATRIX3FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7661
PFNGLPROGRAMUNIFORMMATRIX4FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7662
PFNGLPROGRAMUNIFORMMATRIX2DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7663
PFNGLPROGRAMUNIFORMMATRIX3DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7664
PFNGLPROGRAMUNIFORMMATRIX4DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7665
PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7666
PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7667
PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7668
PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7669
PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7670
PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:7671
PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7672
PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7673
PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7674
PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7675
PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7676
PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:7677
PFNGLVALIDATEPROGRAMPIPELINEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:7678
PFNGLGETPROGRAMPIPELINEINFOLOGPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7679
# ARB_vertex_attrib_64bit (GL/glext.h:7682)
GL_ARB_vertex_attrib_64bit = 1 # GL/glext.h:7683
# GL/glext.h:7685
glVertexAttribL1d = _link_function('glVertexAttribL1d', None, [GLuint, GLdouble], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7686
glVertexAttribL2d = _link_function('glVertexAttribL2d', None, [GLuint, GLdouble, GLdouble], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7687
glVertexAttribL3d = _link_function('glVertexAttribL3d', None, [GLuint, GLdouble, GLdouble, GLdouble], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7688
glVertexAttribL4d = _link_function('glVertexAttribL4d', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7689
glVertexAttribL1dv = _link_function('glVertexAttribL1dv', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7690
glVertexAttribL2dv = _link_function('glVertexAttribL2dv', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7691
glVertexAttribL3dv = _link_function('glVertexAttribL3dv', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7692
glVertexAttribL4dv = _link_function('glVertexAttribL4dv', None, [GLuint, POINTER(GLdouble)], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7693
glVertexAttribLPointer = _link_function('glVertexAttribLPointer', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_vertex_attrib_64bit')
# GL/glext.h:7694
glGetVertexAttribLdv = _link_function('glGetVertexAttribLdv', None, [GLuint, GLenum, POINTER(GLdouble)], 'ARB_vertex_attrib_64bit')
PFNGLVERTEXATTRIBL1DPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:7696
PFNGLVERTEXATTRIBL2DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:7697
PFNGLVERTEXATTRIBL3DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:7698
PFNGLVERTEXATTRIBL4DPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:7699
PFNGLVERTEXATTRIBL1DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:7700
PFNGLVERTEXATTRIBL2DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:7701
PFNGLVERTEXATTRIBL3DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:7702
PFNGLVERTEXATTRIBL4DVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:7703
PFNGLVERTEXATTRIBLPOINTERPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7704
PFNGLGETVERTEXATTRIBLDVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:7705
# ARB_viewport_array (GL/glext.h:7708)
GL_ARB_viewport_array = 1 # GL/glext.h:7709
# GL/glext.h:7711
glViewportArrayv = _link_function('glViewportArrayv', None, [GLuint, GLsizei, POINTER(GLfloat)], 'ARB_viewport_array')
# GL/glext.h:7712
glViewportIndexedf = _link_function('glViewportIndexedf', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'ARB_viewport_array')
# GL/glext.h:7713
glViewportIndexedfv = _link_function('glViewportIndexedfv', None, [GLuint, POINTER(GLfloat)], 'ARB_viewport_array')
# GL/glext.h:7714
glScissorArrayv = _link_function('glScissorArrayv', None, [GLuint, GLsizei, POINTER(GLint)], 'ARB_viewport_array')
# GL/glext.h:7715
glScissorIndexed = _link_function('glScissorIndexed', None, [GLuint, GLint, GLint, GLsizei, GLsizei], 'ARB_viewport_array')
# GL/glext.h:7716
glScissorIndexedv = _link_function('glScissorIndexedv', None, [GLuint, POINTER(GLint)], 'ARB_viewport_array')
# GL/glext.h:7717
glDepthRangeArrayv = _link_function('glDepthRangeArrayv', None, [GLuint, GLsizei, POINTER(GLdouble)], 'ARB_viewport_array')
# GL/glext.h:7718
glDepthRangeIndexed = _link_function('glDepthRangeIndexed', None, [GLuint, GLdouble, GLdouble], 'ARB_viewport_array')
# GL/glext.h:7719
glGetFloati_v = _link_function('glGetFloati_v', None, [GLenum, GLuint, POINTER(GLfloat)], 'ARB_viewport_array')
# GL/glext.h:7720
glGetDoublei_v = _link_function('glGetDoublei_v', None, [GLenum, GLuint, POINTER(GLdouble)], 'ARB_viewport_array')
PFNGLVIEWPORTARRAYVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7722
PFNGLVIEWPORTINDEXEDFPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:7723
PFNGLVIEWPORTINDEXEDFVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:7724
PFNGLSCISSORARRAYVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:7725
PFNGLSCISSORINDEXEDPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:7726
PFNGLSCISSORINDEXEDVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:7727
PFNGLDEPTHRANGEARRAYVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7728
PFNGLDEPTHRANGEINDEXEDPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:7729
PFNGLGETFLOATI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:7730
PFNGLGETDOUBLEI_VPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:7731
# ARB_cl_event (GL/glext.h:7734)
GL_ARB_cl_event = 1 # GL/glext.h:7735
class struct__cl_context(Structure):
__slots__ = [
]
struct__cl_context._fields_ = [
('_opaque_struct', c_int)
]
class struct__cl_event(Structure):
__slots__ = [
]
struct__cl_event._fields_ = [
('_opaque_struct', c_int)
]
# GL/glext.h:7737
glCreateSyncFromCLeventARB = _link_function('glCreateSyncFromCLeventARB', GLsync, [POINTER(struct__cl_context), POINTER(struct__cl_event), GLbitfield], 'ARB_cl_event')
class struct__cl_context(Structure):
__slots__ = [
]
struct__cl_context._fields_ = [
('_opaque_struct', c_int)
]
class struct__cl_event(Structure):
__slots__ = [
]
struct__cl_event._fields_ = [
('_opaque_struct', c_int)
]
class struct__cl_context(Structure):
__slots__ = [
]
struct__cl_context._fields_ = [
('_opaque_struct', c_int)
]
class struct__cl_event(Structure):
__slots__ = [
]
struct__cl_event._fields_ = [
('_opaque_struct', c_int)
]
PFNGLCREATESYNCFROMCLEVENTARBPROC = CFUNCTYPE(GLsync, POINTER(struct__cl_context), POINTER(struct__cl_event), GLbitfield) # GL/glext.h:7739
# ARB_debug_output (GL/glext.h:7742)
GL_ARB_debug_output = 1 # GL/glext.h:7743
# GL/glext.h:7745
glDebugMessageControlARB = _link_function('glDebugMessageControlARB', None, [GLenum, GLenum, GLenum, GLsizei, POINTER(GLuint), GLboolean], 'ARB_debug_output')
# GL/glext.h:7746
glDebugMessageInsertARB = _link_function('glDebugMessageInsertARB', None, [GLenum, GLenum, GLuint, GLenum, GLsizei, POINTER(GLchar)], 'ARB_debug_output')
# GL/glext.h:7747
glDebugMessageCallbackARB = _link_function('glDebugMessageCallbackARB', None, [GLDEBUGPROCARB, POINTER(GLvoid)], 'ARB_debug_output')
# GL/glext.h:7748
glGetDebugMessageLogARB = _link_function('glGetDebugMessageLogARB', GLuint, [GLuint, GLsizei, POINTER(GLenum), POINTER(GLenum), POINTER(GLuint), POINTER(GLenum), POINTER(GLsizei), POINTER(GLchar)], 'ARB_debug_output')
PFNGLDEBUGMESSAGECONTROLARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLsizei, POINTER(GLuint), GLboolean) # GL/glext.h:7750
PFNGLDEBUGMESSAGEINSERTARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLenum, GLsizei, POINTER(GLchar)) # GL/glext.h:7751
PFNGLDEBUGMESSAGECALLBACKARBPROC = CFUNCTYPE(None, GLDEBUGPROCARB, POINTER(GLvoid)) # GL/glext.h:7752
PFNGLGETDEBUGMESSAGELOGARBPROC = CFUNCTYPE(GLuint, GLuint, GLsizei, POINTER(GLenum), POINTER(GLenum), POINTER(GLuint), POINTER(GLenum), POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:7753
# ARB_robustness (GL/glext.h:7756)
GL_ARB_robustness = 1 # GL/glext.h:7757
# GL/glext.h:7759
glGetGraphicsResetStatusARB = _link_function('glGetGraphicsResetStatusARB', GLenum, [], 'ARB_robustness')
# GL/glext.h:7760
glGetnMapdvARB = _link_function('glGetnMapdvARB', None, [GLenum, GLenum, GLsizei, POINTER(GLdouble)], 'ARB_robustness')
# GL/glext.h:7761
glGetnMapfvARB = _link_function('glGetnMapfvARB', None, [GLenum, GLenum, GLsizei, POINTER(GLfloat)], 'ARB_robustness')
# GL/glext.h:7762
glGetnMapivARB = _link_function('glGetnMapivARB', None, [GLenum, GLenum, GLsizei, POINTER(GLint)], 'ARB_robustness')
# GL/glext.h:7763
glGetnPixelMapfvARB = _link_function('glGetnPixelMapfvARB', None, [GLenum, GLsizei, POINTER(GLfloat)], 'ARB_robustness')
# GL/glext.h:7764
glGetnPixelMapuivARB = _link_function('glGetnPixelMapuivARB', None, [GLenum, GLsizei, POINTER(GLuint)], 'ARB_robustness')
# GL/glext.h:7765
glGetnPixelMapusvARB = _link_function('glGetnPixelMapusvARB', None, [GLenum, GLsizei, POINTER(GLushort)], 'ARB_robustness')
# GL/glext.h:7766
glGetnPolygonStippleARB = _link_function('glGetnPolygonStippleARB', None, [GLsizei, POINTER(GLubyte)], 'ARB_robustness')
# GL/glext.h:7767
glGetnColorTableARB = _link_function('glGetnColorTableARB', None, [GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7768
glGetnConvolutionFilterARB = _link_function('glGetnConvolutionFilterARB', None, [GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7769
glGetnSeparableFilterARB = _link_function('glGetnSeparableFilterARB', None, [GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid), GLsizei, POINTER(GLvoid), POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7770
glGetnHistogramARB = _link_function('glGetnHistogramARB', None, [GLenum, GLboolean, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7771
glGetnMinmaxARB = _link_function('glGetnMinmaxARB', None, [GLenum, GLboolean, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7772
glGetnTexImageARB = _link_function('glGetnTexImageARB', None, [GLenum, GLint, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7773
glReadnPixelsARB = _link_function('glReadnPixelsARB', None, [GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7774
glGetnCompressedTexImageARB = _link_function('glGetnCompressedTexImageARB', None, [GLenum, GLint, GLsizei, POINTER(GLvoid)], 'ARB_robustness')
# GL/glext.h:7775
glGetnUniformfvARB = _link_function('glGetnUniformfvARB', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'ARB_robustness')
# GL/glext.h:7776
glGetnUniformivARB = _link_function('glGetnUniformivARB', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'ARB_robustness')
# GL/glext.h:7777
glGetnUniformuivARB = _link_function('glGetnUniformuivARB', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'ARB_robustness')
# GL/glext.h:7778
glGetnUniformdvARB = _link_function('glGetnUniformdvARB', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'ARB_robustness')
PFNGLGETGRAPHICSRESETSTATUSARBPROC = CFUNCTYPE(GLenum) # GL/glext.h:7780
PFNGLGETNMAPDVARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLdouble)) # GL/glext.h:7781
PFNGLGETNMAPFVARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:7782
PFNGLGETNMAPIVARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLint)) # GL/glext.h:7783
PFNGLGETNPIXELMAPFVARBPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:7784
PFNGLGETNPIXELMAPUIVARBPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLuint)) # GL/glext.h:7785
PFNGLGETNPIXELMAPUSVARBPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLushort)) # GL/glext.h:7786
PFNGLGETNPOLYGONSTIPPLEARBPROC = CFUNCTYPE(None, GLsizei, POINTER(GLubyte)) # GL/glext.h:7787
PFNGLGETNCOLORTABLEARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7788
PFNGLGETNCONVOLUTIONFILTERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7789
PFNGLGETNSEPARABLEFILTERARBPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLsizei, POINTER(GLvoid), GLsizei, POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:7790
PFNGLGETNHISTOGRAMARBPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7791
PFNGLGETNMINMAXARBPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7792
PFNGLGETNTEXIMAGEARBPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7793
PFNGLREADNPIXELSARBPROC = CFUNCTYPE(None, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:7794
PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:7795
PFNGLGETNUNIFORMFVARBPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:7796
PFNGLGETNUNIFORMIVARBPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:7797
PFNGLGETNUNIFORMUIVARBPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:7798
PFNGLGETNUNIFORMDVARBPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:7799
# ARB_shader_stencil_export (GL/glext.h:7802)
GL_ARB_shader_stencil_export = 1 # GL/glext.h:7803
# ARB_base_instance (GL/glext.h:7806)
GL_ARB_base_instance = 1 # GL/glext.h:7807
# GL/glext.h:7809
glDrawArraysInstancedBaseInstance = _link_function('glDrawArraysInstancedBaseInstance', None, [GLenum, GLint, GLsizei, GLsizei, GLuint], 'ARB_base_instance')
# GL/glext.h:7810
glDrawElementsInstancedBaseInstance = _link_function('glDrawElementsInstancedBaseInstance', None, [GLenum, GLsizei, GLenum, POINTER(None), GLsizei, GLuint], 'ARB_base_instance')
# GL/glext.h:7811
glDrawElementsInstancedBaseVertexBaseInstance = _link_function('glDrawElementsInstancedBaseVertexBaseInstance', None, [GLenum, GLsizei, GLenum, POINTER(None), GLsizei, GLint, GLuint], 'ARB_base_instance')
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei, GLuint) # GL/glext.h:7813
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(None), GLsizei, GLuint) # GL/glext.h:7814
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(None), GLsizei, GLint, GLuint) # GL/glext.h:7815
# ARB_shading_language_420pack (GL/glext.h:7818)
GL_ARB_shading_language_420pack = 1 # GL/glext.h:7819
# ARB_transform_feedback_instanced (GL/glext.h:7822)
GL_ARB_transform_feedback_instanced = 1 # GL/glext.h:7823
# GL/glext.h:7825
glDrawTransformFeedbackInstanced = _link_function('glDrawTransformFeedbackInstanced', None, [GLenum, GLuint, GLsizei], 'ARB_transform_feedback_instanced')
# GL/glext.h:7826
glDrawTransformFeedbackStreamInstanced = _link_function('glDrawTransformFeedbackStreamInstanced', None, [GLenum, GLuint, GLuint, GLsizei], 'ARB_transform_feedback_instanced')
PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei) # GL/glext.h:7828
PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei) # GL/glext.h:7829
# ARB_compressed_texture_pixel_storage (GL/glext.h:7832)
GL_ARB_compressed_texture_pixel_storage = 1 # GL/glext.h:7833
# ARB_conservative_depth (GL/glext.h:7836)
GL_ARB_conservative_depth = 1 # GL/glext.h:7837
# ARB_internalformat_query (GL/glext.h:7840)
GL_ARB_internalformat_query = 1 # GL/glext.h:7841
# GL/glext.h:7843
glGetInternalformativ = _link_function('glGetInternalformativ', None, [GLenum, GLenum, GLenum, GLsizei, POINTER(GLint)], 'ARB_internalformat_query')
PFNGLGETINTERNALFORMATIVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLsizei, POINTER(GLint)) # GL/glext.h:7845
# ARB_map_buffer_alignment (GL/glext.h:7848)
GL_ARB_map_buffer_alignment = 1 # GL/glext.h:7849
# ARB_shader_atomic_counters (GL/glext.h:7852)
GL_ARB_shader_atomic_counters = 1 # GL/glext.h:7853
# GL/glext.h:7855
glGetActiveAtomicCounterBufferiv = _link_function('glGetActiveAtomicCounterBufferiv', None, [GLuint, GLuint, GLenum, POINTER(GLint)], 'ARB_shader_atomic_counters')
PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:7857
# ARB_shader_image_load_store (GL/glext.h:7860)
GL_ARB_shader_image_load_store = 1 # GL/glext.h:7861
# GL/glext.h:7863
glBindImageTexture = _link_function('glBindImageTexture', None, [GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum], 'ARB_shader_image_load_store')
# GL/glext.h:7864
glMemoryBarrier = _link_function('glMemoryBarrier', None, [GLbitfield], 'ARB_shader_image_load_store')
PFNGLBINDIMAGETEXTUREPROC = CFUNCTYPE(None, GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum) # GL/glext.h:7866
PFNGLMEMORYBARRIERPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:7867
# ARB_shading_language_packing (GL/glext.h:7870)
GL_ARB_shading_language_packing = 1 # GL/glext.h:7871
# ARB_texture_storage (GL/glext.h:7874)
GL_ARB_texture_storage = 1 # GL/glext.h:7875
# GL/glext.h:7877
glTexStorage1D = _link_function('glTexStorage1D', None, [GLenum, GLsizei, GLenum, GLsizei], 'ARB_texture_storage')
# GL/glext.h:7878
glTexStorage2D = _link_function('glTexStorage2D', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'ARB_texture_storage')
# GL/glext.h:7879
glTexStorage3D = _link_function('glTexStorage3D', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei], 'ARB_texture_storage')
# GL/glext.h:7880
glTextureStorage1DEXT = _link_function('glTextureStorage1DEXT', None, [GLuint, GLenum, GLsizei, GLenum, GLsizei], 'ARB_texture_storage')
# GL/glext.h:7881
glTextureStorage2DEXT = _link_function('glTextureStorage2DEXT', None, [GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'ARB_texture_storage')
# GL/glext.h:7882
glTextureStorage3DEXT = _link_function('glTextureStorage3DEXT', None, [GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei], 'ARB_texture_storage')
PFNGLTEXSTORAGE1DPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei) # GL/glext.h:7884
PFNGLTEXSTORAGE2DPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:7885
PFNGLTEXSTORAGE3DPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei) # GL/glext.h:7886
PFNGLTEXTURESTORAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLenum, GLsizei) # GL/glext.h:7887
PFNGLTEXTURESTORAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:7888
PFNGLTEXTURESTORAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei) # GL/glext.h:7889
# EXT_abgr (GL/glext.h:7892)
GL_EXT_abgr = 1 # GL/glext.h:7893
# EXT_blend_color (GL/glext.h:7896)
GL_EXT_blend_color = 1 # GL/glext.h:7897
# GL/glext.h:7899
glBlendColorEXT = _link_function('glBlendColorEXT', None, [GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_blend_color')
PFNGLBLENDCOLOREXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:7901
# EXT_polygon_offset (GL/glext.h:7904)
GL_EXT_polygon_offset = 1 # GL/glext.h:7905
# GL/glext.h:7907
glPolygonOffsetEXT = _link_function('glPolygonOffsetEXT', None, [GLfloat, GLfloat], 'EXT_polygon_offset')
PFNGLPOLYGONOFFSETEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:7909
# EXT_texture (GL/glext.h:7912)
GL_EXT_texture = 1 # GL/glext.h:7913
# EXT_texture3D (GL/glext.h:7916)
GL_EXT_texture3D = 1 # GL/glext.h:7917
# GL/glext.h:7919
glTexImage3DEXT = _link_function('glTexImage3DEXT', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_texture3D')
# GL/glext.h:7920
glTexSubImage3DEXT = _link_function('glTexSubImage3DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_texture3D')
PFNGLTEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7922
PFNGLTEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7923
# SGIS_texture_filter4 (GL/glext.h:7926)
GL_SGIS_texture_filter4 = 1 # GL/glext.h:7927
# GL/glext.h:7929
glGetTexFilterFuncSGIS = _link_function('glGetTexFilterFuncSGIS', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIS_texture_filter4')
# GL/glext.h:7930
glTexFilterFuncSGIS = _link_function('glTexFilterFuncSGIS', None, [GLenum, GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_texture_filter4')
PFNGLGETTEXFILTERFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:7932
PFNGLTEXFILTERFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:7933
# EXT_subtexture (GL/glext.h:7936)
GL_EXT_subtexture = 1 # GL/glext.h:7937
# GL/glext.h:7939
glTexSubImage1DEXT = _link_function('glTexSubImage1DEXT', None, [GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_subtexture')
# GL/glext.h:7940
glTexSubImage2DEXT = _link_function('glTexSubImage2DEXT', None, [GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_subtexture')
PFNGLTEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7942
PFNGLTEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7943
# EXT_copy_texture (GL/glext.h:7946)
GL_EXT_copy_texture = 1 # GL/glext.h:7947
# GL/glext.h:7949
glCopyTexImage1DEXT = _link_function('glCopyTexImage1DEXT', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_copy_texture')
# GL/glext.h:7950
glCopyTexImage2DEXT = _link_function('glCopyTexImage2DEXT', None, [GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_copy_texture')
# GL/glext.h:7951
glCopyTexSubImage1DEXT = _link_function('glCopyTexSubImage1DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_copy_texture')
# GL/glext.h:7952
glCopyTexSubImage2DEXT = _link_function('glCopyTexSubImage2DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_copy_texture')
# GL/glext.h:7953
glCopyTexSubImage3DEXT = _link_function('glCopyTexSubImage3DEXT', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_copy_texture')
PFNGLCOPYTEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:7955
PFNGLCOPYTEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:7956
PFNGLCOPYTEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:7957
PFNGLCOPYTEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:7958
PFNGLCOPYTEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:7959
# EXT_histogram (GL/glext.h:7962)
GL_EXT_histogram = 1 # GL/glext.h:7963
# GL/glext.h:7965
glGetHistogramEXT = _link_function('glGetHistogramEXT', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'EXT_histogram')
# GL/glext.h:7966
glGetHistogramParameterfvEXT = _link_function('glGetHistogramParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_histogram')
# GL/glext.h:7967
glGetHistogramParameterivEXT = _link_function('glGetHistogramParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_histogram')
# GL/glext.h:7968
glGetMinmaxEXT = _link_function('glGetMinmaxEXT', None, [GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)], 'EXT_histogram')
# GL/glext.h:7969
glGetMinmaxParameterfvEXT = _link_function('glGetMinmaxParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_histogram')
# GL/glext.h:7970
glGetMinmaxParameterivEXT = _link_function('glGetMinmaxParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_histogram')
# GL/glext.h:7971
glHistogramEXT = _link_function('glHistogramEXT', None, [GLenum, GLsizei, GLenum, GLboolean], 'EXT_histogram')
# GL/glext.h:7972
glMinmaxEXT = _link_function('glMinmaxEXT', None, [GLenum, GLenum, GLboolean], 'EXT_histogram')
# GL/glext.h:7973
glResetHistogramEXT = _link_function('glResetHistogramEXT', None, [GLenum], 'EXT_histogram')
# GL/glext.h:7974
glResetMinmaxEXT = _link_function('glResetMinmaxEXT', None, [GLenum], 'EXT_histogram')
PFNGLGETHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7976
PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:7977
PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7978
PFNGLGETMINMAXEXTPROC = CFUNCTYPE(None, GLenum, GLboolean, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:7979
PFNGLGETMINMAXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:7980
PFNGLGETMINMAXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:7981
PFNGLHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLboolean) # GL/glext.h:7982
PFNGLMINMAXEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLboolean) # GL/glext.h:7983
PFNGLRESETHISTOGRAMEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7984
PFNGLRESETMINMAXEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:7985
# EXT_convolution (GL/glext.h:7988)
GL_EXT_convolution = 1 # GL/glext.h:7989
# GL/glext.h:7991
glConvolutionFilter1DEXT = _link_function('glConvolutionFilter1DEXT', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:7992
glConvolutionFilter2DEXT = _link_function('glConvolutionFilter2DEXT', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:7993
glConvolutionParameterfEXT = _link_function('glConvolutionParameterfEXT', None, [GLenum, GLenum, GLfloat], 'EXT_convolution')
# GL/glext.h:7994
glConvolutionParameterfvEXT = _link_function('glConvolutionParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_convolution')
# GL/glext.h:7995
glConvolutionParameteriEXT = _link_function('glConvolutionParameteriEXT', None, [GLenum, GLenum, GLint], 'EXT_convolution')
# GL/glext.h:7996
glConvolutionParameterivEXT = _link_function('glConvolutionParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_convolution')
# GL/glext.h:7997
glCopyConvolutionFilter1DEXT = _link_function('glCopyConvolutionFilter1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'EXT_convolution')
# GL/glext.h:7998
glCopyConvolutionFilter2DEXT = _link_function('glCopyConvolutionFilter2DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLsizei], 'EXT_convolution')
# GL/glext.h:7999
glGetConvolutionFilterEXT = _link_function('glGetConvolutionFilterEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:8000
glGetConvolutionParameterfvEXT = _link_function('glGetConvolutionParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_convolution')
# GL/glext.h:8001
glGetConvolutionParameterivEXT = _link_function('glGetConvolutionParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_convolution')
# GL/glext.h:8002
glGetSeparableFilterEXT = _link_function('glGetSeparableFilterEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)], 'EXT_convolution')
# GL/glext.h:8003
glSeparableFilter2DEXT = _link_function('glSeparableFilter2DEXT', None, [GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)], 'EXT_convolution')
PFNGLCONVOLUTIONFILTER1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8005
PFNGLCONVOLUTIONFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8006
PFNGLCONVOLUTIONPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:8007
PFNGLCONVOLUTIONPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8008
PFNGLCONVOLUTIONPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:8009
PFNGLCONVOLUTIONPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8010
PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:8011
PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:8012
PFNGLGETCONVOLUTIONFILTEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8013
PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8014
PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8015
PFNGLGETSEPARABLEFILTEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:8016
PFNGLSEPARABLEFILTER2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:8017
# SGI_color_matrix (GL/glext.h:8020)
GL_SGI_color_matrix = 1 # GL/glext.h:8021
# SGI_color_table (GL/glext.h:8024)
GL_SGI_color_table = 1 # GL/glext.h:8025
# GL/glext.h:8027
glColorTableSGI = _link_function('glColorTableSGI', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'SGI_color_table')
# GL/glext.h:8028
glColorTableParameterfvSGI = _link_function('glColorTableParameterfvSGI', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGI_color_table')
# GL/glext.h:8029
glColorTableParameterivSGI = _link_function('glColorTableParameterivSGI', None, [GLenum, GLenum, POINTER(GLint)], 'SGI_color_table')
# GL/glext.h:8030
glCopyColorTableSGI = _link_function('glCopyColorTableSGI', None, [GLenum, GLenum, GLint, GLint, GLsizei], 'SGI_color_table')
# GL/glext.h:8031
glGetColorTableSGI = _link_function('glGetColorTableSGI', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'SGI_color_table')
# GL/glext.h:8032
glGetColorTableParameterfvSGI = _link_function('glGetColorTableParameterfvSGI', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGI_color_table')
# GL/glext.h:8033
glGetColorTableParameterivSGI = _link_function('glGetColorTableParameterivSGI', None, [GLenum, GLenum, POINTER(GLint)], 'SGI_color_table')
PFNGLCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8035
PFNGLCOLORTABLEPARAMETERFVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8036
PFNGLCOLORTABLEPARAMETERIVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8037
PFNGLCOPYCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei) # GL/glext.h:8038
PFNGLGETCOLORTABLESGIPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8039
PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8040
PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8041
# SGIX_pixel_texture (GL/glext.h:8044)
GL_SGIX_pixel_texture = 1 # GL/glext.h:8045
# GL/glext.h:8047
glPixelTexGenSGIX = _link_function('glPixelTexGenSGIX', None, [GLenum], 'SGIX_pixel_texture')
PFNGLPIXELTEXGENSGIXPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8049
# SGIS_pixel_texture (GL/glext.h:8052)
GL_SGIS_pixel_texture = 1 # GL/glext.h:8053
# GL/glext.h:8055
glPixelTexGenParameteriSGIS = _link_function('glPixelTexGenParameteriSGIS', None, [GLenum, GLint], 'SGIS_pixel_texture')
# GL/glext.h:8056
glPixelTexGenParameterivSGIS = _link_function('glPixelTexGenParameterivSGIS', None, [GLenum, POINTER(GLint)], 'SGIS_pixel_texture')
# GL/glext.h:8057
glPixelTexGenParameterfSGIS = _link_function('glPixelTexGenParameterfSGIS', None, [GLenum, GLfloat], 'SGIS_pixel_texture')
# GL/glext.h:8058
glPixelTexGenParameterfvSGIS = _link_function('glPixelTexGenParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_pixel_texture')
# GL/glext.h:8059
glGetPixelTexGenParameterivSGIS = _link_function('glGetPixelTexGenParameterivSGIS', None, [GLenum, POINTER(GLint)], 'SGIS_pixel_texture')
# GL/glext.h:8060
glGetPixelTexGenParameterfvSGIS = _link_function('glGetPixelTexGenParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_pixel_texture')
PFNGLPIXELTEXGENPARAMETERISGISPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:8062
PFNGLPIXELTEXGENPARAMETERIVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:8063
PFNGLPIXELTEXGENPARAMETERFSGISPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:8064
PFNGLPIXELTEXGENPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8065
PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:8066
PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8067
# SGIS_texture4D (GL/glext.h:8070)
GL_SGIS_texture4D = 1 # GL/glext.h:8071
# GL/glext.h:8073
glTexImage4DSGIS = _link_function('glTexImage4DSGIS', None, [GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'SGIS_texture4D')
# GL/glext.h:8074
glTexSubImage4DSGIS = _link_function('glTexSubImage4DSGIS', None, [GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'SGIS_texture4D')
PFNGLTEXIMAGE4DSGISPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8076
PFNGLTEXSUBIMAGE4DSGISPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8077
# SGI_texture_color_table (GL/glext.h:8080)
GL_SGI_texture_color_table = 1 # GL/glext.h:8081
# EXT_cmyka (GL/glext.h:8084)
GL_EXT_cmyka = 1 # GL/glext.h:8085
# EXT_texture_object (GL/glext.h:8088)
GL_EXT_texture_object = 1 # GL/glext.h:8089
# GL/glext.h:8091
glAreTexturesResidentEXT = _link_function('glAreTexturesResidentEXT', GLboolean, [GLsizei, POINTER(GLuint), POINTER(GLboolean)], 'EXT_texture_object')
# GL/glext.h:8092
glBindTextureEXT = _link_function('glBindTextureEXT', None, [GLenum, GLuint], 'EXT_texture_object')
# GL/glext.h:8093
glDeleteTexturesEXT = _link_function('glDeleteTexturesEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_texture_object')
# GL/glext.h:8094
glGenTexturesEXT = _link_function('glGenTexturesEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_texture_object')
# GL/glext.h:8095
glIsTextureEXT = _link_function('glIsTextureEXT', GLboolean, [GLuint], 'EXT_texture_object')
GLclampf = c_float # /usr/include/GL/gl.h:161
# GL/glext.h:8096
glPrioritizeTexturesEXT = _link_function('glPrioritizeTexturesEXT', None, [GLsizei, POINTER(GLuint), POINTER(GLclampf)], 'EXT_texture_object')
PFNGLARETEXTURESRESIDENTEXTPROC = CFUNCTYPE(GLboolean, GLsizei, POINTER(GLuint), POINTER(GLboolean)) # GL/glext.h:8098
PFNGLBINDTEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:8099
PFNGLDELETETEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:8100
PFNGLGENTEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:8101
PFNGLISTEXTUREEXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:8102
PFNGLPRIORITIZETEXTURESEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint), POINTER(GLclampf)) # GL/glext.h:8103
# SGIS_detail_texture (GL/glext.h:8106)
GL_SGIS_detail_texture = 1 # GL/glext.h:8107
# GL/glext.h:8109
glDetailTexFuncSGIS = _link_function('glDetailTexFuncSGIS', None, [GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_detail_texture')
# GL/glext.h:8110
glGetDetailTexFuncSGIS = _link_function('glGetDetailTexFuncSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_detail_texture')
PFNGLDETAILTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:8112
PFNGLGETDETAILTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8113
# SGIS_sharpen_texture (GL/glext.h:8116)
GL_SGIS_sharpen_texture = 1 # GL/glext.h:8117
# GL/glext.h:8119
glSharpenTexFuncSGIS = _link_function('glSharpenTexFuncSGIS', None, [GLenum, GLsizei, POINTER(GLfloat)], 'SGIS_sharpen_texture')
# GL/glext.h:8120
glGetSharpenTexFuncSGIS = _link_function('glGetSharpenTexFuncSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_sharpen_texture')
PFNGLSHARPENTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLfloat)) # GL/glext.h:8122
PFNGLGETSHARPENTEXFUNCSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8123
# EXT_packed_pixels (GL/glext.h:8126)
GL_EXT_packed_pixels = 1 # GL/glext.h:8127
# SGIS_texture_lod (GL/glext.h:8130)
GL_SGIS_texture_lod = 1 # GL/glext.h:8131
# SGIS_multisample (GL/glext.h:8134)
GL_SGIS_multisample = 1 # GL/glext.h:8135
# GL/glext.h:8137
glSampleMaskSGIS = _link_function('glSampleMaskSGIS', None, [GLclampf, GLboolean], 'SGIS_multisample')
# GL/glext.h:8138
glSamplePatternSGIS = _link_function('glSamplePatternSGIS', None, [GLenum], 'SGIS_multisample')
PFNGLSAMPLEMASKSGISPROC = CFUNCTYPE(None, GLclampf, GLboolean) # GL/glext.h:8140
PFNGLSAMPLEPATTERNSGISPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8141
# EXT_rescale_normal (GL/glext.h:8144)
GL_EXT_rescale_normal = 1 # GL/glext.h:8145
# EXT_vertex_array (GL/glext.h:8148)
GL_EXT_vertex_array = 1 # GL/glext.h:8149
# GL/glext.h:8151
glArrayElementEXT = _link_function('glArrayElementEXT', None, [GLint], 'EXT_vertex_array')
# GL/glext.h:8152
glColorPointerEXT = _link_function('glColorPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:8153
glDrawArraysEXT = _link_function('glDrawArraysEXT', None, [GLenum, GLint, GLsizei], 'EXT_vertex_array')
# GL/glext.h:8154
glEdgeFlagPointerEXT = _link_function('glEdgeFlagPointerEXT', None, [GLsizei, GLsizei, POINTER(GLboolean)], 'EXT_vertex_array')
# GL/glext.h:8155
glGetPointervEXT = _link_function('glGetPointervEXT', None, [GLenum, POINTER(POINTER(GLvoid))], 'EXT_vertex_array')
# GL/glext.h:8156
glIndexPointerEXT = _link_function('glIndexPointerEXT', None, [GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:8157
glNormalPointerEXT = _link_function('glNormalPointerEXT', None, [GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:8158
glTexCoordPointerEXT = _link_function('glTexCoordPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
# GL/glext.h:8159
glVertexPointerEXT = _link_function('glVertexPointerEXT', None, [GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)], 'EXT_vertex_array')
PFNGLARRAYELEMENTEXTPROC = CFUNCTYPE(None, GLint) # GL/glext.h:8161
PFNGLCOLORPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:8162
PFNGLDRAWARRAYSEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei) # GL/glext.h:8163
PFNGLEDGEFLAGPOINTEREXTPROC = CFUNCTYPE(None, GLsizei, GLsizei, POINTER(GLboolean)) # GL/glext.h:8164
PFNGLGETPOINTERVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8165
PFNGLINDEXPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:8166
PFNGLNORMALPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:8167
PFNGLTEXCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:8168
PFNGLVERTEXPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, GLsizei, POINTER(GLvoid)) # GL/glext.h:8169
# EXT_misc_attribute (GL/glext.h:8172)
GL_EXT_misc_attribute = 1 # GL/glext.h:8173
# SGIS_generate_mipmap (GL/glext.h:8176)
GL_SGIS_generate_mipmap = 1 # GL/glext.h:8177
# SGIX_clipmap (GL/glext.h:8180)
GL_SGIX_clipmap = 1 # GL/glext.h:8181
# SGIX_shadow (GL/glext.h:8184)
GL_SGIX_shadow = 1 # GL/glext.h:8185
# SGIS_texture_edge_clamp (GL/glext.h:8188)
GL_SGIS_texture_edge_clamp = 1 # GL/glext.h:8189
# SGIS_texture_border_clamp (GL/glext.h:8192)
GL_SGIS_texture_border_clamp = 1 # GL/glext.h:8193
# EXT_blend_minmax (GL/glext.h:8196)
GL_EXT_blend_minmax = 1 # GL/glext.h:8197
# GL/glext.h:8199
glBlendEquationEXT = _link_function('glBlendEquationEXT', None, [GLenum], 'EXT_blend_minmax')
PFNGLBLENDEQUATIONEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8201
# EXT_blend_subtract (GL/glext.h:8204)
GL_EXT_blend_subtract = 1 # GL/glext.h:8205
# EXT_blend_logic_op (GL/glext.h:8208)
GL_EXT_blend_logic_op = 1 # GL/glext.h:8209
# SGIX_interlace (GL/glext.h:8212)
GL_SGIX_interlace = 1 # GL/glext.h:8213
# SGIX_pixel_tiles (GL/glext.h:8216)
GL_SGIX_pixel_tiles = 1 # GL/glext.h:8217
# SGIX_texture_select (GL/glext.h:8220)
GL_SGIX_texture_select = 1 # GL/glext.h:8221
# SGIX_sprite (GL/glext.h:8224)
GL_SGIX_sprite = 1 # GL/glext.h:8225
# GL/glext.h:8227
glSpriteParameterfSGIX = _link_function('glSpriteParameterfSGIX', None, [GLenum, GLfloat], 'SGIX_sprite')
# GL/glext.h:8228
glSpriteParameterfvSGIX = _link_function('glSpriteParameterfvSGIX', None, [GLenum, POINTER(GLfloat)], 'SGIX_sprite')
# GL/glext.h:8229
glSpriteParameteriSGIX = _link_function('glSpriteParameteriSGIX', None, [GLenum, GLint], 'SGIX_sprite')
# GL/glext.h:8230
glSpriteParameterivSGIX = _link_function('glSpriteParameterivSGIX', None, [GLenum, POINTER(GLint)], 'SGIX_sprite')
PFNGLSPRITEPARAMETERFSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:8232
PFNGLSPRITEPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8233
PFNGLSPRITEPARAMETERISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:8234
PFNGLSPRITEPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:8235
# SGIX_texture_multi_buffer (GL/glext.h:8238)
GL_SGIX_texture_multi_buffer = 1 # GL/glext.h:8239
# EXT_point_parameters (GL/glext.h:8242)
GL_EXT_point_parameters = 1 # GL/glext.h:8243
# GL/glext.h:8245
glPointParameterfEXT = _link_function('glPointParameterfEXT', None, [GLenum, GLfloat], 'EXT_point_parameters')
# GL/glext.h:8246
glPointParameterfvEXT = _link_function('glPointParameterfvEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_point_parameters')
PFNGLPOINTPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:8248
PFNGLPOINTPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8249
# SGIS_point_parameters (GL/glext.h:8252)
GL_SGIS_point_parameters = 1 # GL/glext.h:8253
# GL/glext.h:8255
glPointParameterfSGIS = _link_function('glPointParameterfSGIS', None, [GLenum, GLfloat], 'SGIS_point_parameters')
# GL/glext.h:8256
glPointParameterfvSGIS = _link_function('glPointParameterfvSGIS', None, [GLenum, POINTER(GLfloat)], 'SGIS_point_parameters')
PFNGLPOINTPARAMETERFSGISPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:8258
PFNGLPOINTPARAMETERFVSGISPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8259
# SGIX_instruments (GL/glext.h:8262)
GL_SGIX_instruments = 1 # GL/glext.h:8263
# GL/glext.h:8265
glGetInstrumentsSGIX = _link_function('glGetInstrumentsSGIX', GLint, [], 'SGIX_instruments')
# GL/glext.h:8266
glInstrumentsBufferSGIX = _link_function('glInstrumentsBufferSGIX', None, [GLsizei, POINTER(GLint)], 'SGIX_instruments')
# GL/glext.h:8267
glPollInstrumentsSGIX = _link_function('glPollInstrumentsSGIX', GLint, [POINTER(GLint)], 'SGIX_instruments')
# GL/glext.h:8268
glReadInstrumentsSGIX = _link_function('glReadInstrumentsSGIX', None, [GLint], 'SGIX_instruments')
# GL/glext.h:8269
glStartInstrumentsSGIX = _link_function('glStartInstrumentsSGIX', None, [], 'SGIX_instruments')
# GL/glext.h:8270
glStopInstrumentsSGIX = _link_function('glStopInstrumentsSGIX', None, [GLint], 'SGIX_instruments')
PFNGLGETINSTRUMENTSSGIXPROC = CFUNCTYPE(GLint) # GL/glext.h:8272
PFNGLINSTRUMENTSBUFFERSGIXPROC = CFUNCTYPE(None, GLsizei, POINTER(GLint)) # GL/glext.h:8273
PFNGLPOLLINSTRUMENTSSGIXPROC = CFUNCTYPE(GLint, POINTER(GLint)) # GL/glext.h:8274
PFNGLREADINSTRUMENTSSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:8275
PFNGLSTARTINSTRUMENTSSGIXPROC = CFUNCTYPE(None) # GL/glext.h:8276
PFNGLSTOPINSTRUMENTSSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:8277
# SGIX_texture_scale_bias (GL/glext.h:8280)
GL_SGIX_texture_scale_bias = 1 # GL/glext.h:8281
# SGIX_framezoom (GL/glext.h:8284)
GL_SGIX_framezoom = 1 # GL/glext.h:8285
# GL/glext.h:8287
glFrameZoomSGIX = _link_function('glFrameZoomSGIX', None, [GLint], 'SGIX_framezoom')
PFNGLFRAMEZOOMSGIXPROC = CFUNCTYPE(None, GLint) # GL/glext.h:8289
# SGIX_tag_sample_buffer (GL/glext.h:8292)
GL_SGIX_tag_sample_buffer = 1 # GL/glext.h:8293
# GL/glext.h:8295
glTagSampleBufferSGIX = _link_function('glTagSampleBufferSGIX', None, [], 'SGIX_tag_sample_buffer')
PFNGLTAGSAMPLEBUFFERSGIXPROC = CFUNCTYPE(None) # GL/glext.h:8297
# SGIX_polynomial_ffd (GL/glext.h:8300)
GL_SGIX_polynomial_ffd = 1 # GL/glext.h:8301
# GL/glext.h:8303
glDeformationMap3dSGIX = _link_function('glDeformationMap3dSGIX', None, [GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], 'SGIX_polynomial_ffd')
# GL/glext.h:8304
glDeformationMap3fSGIX = _link_function('glDeformationMap3fSGIX', None, [GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], 'SGIX_polynomial_ffd')
# GL/glext.h:8305
glDeformSGIX = _link_function('glDeformSGIX', None, [GLbitfield], 'SGIX_polynomial_ffd')
# GL/glext.h:8306
glLoadIdentityDeformationMapSGIX = _link_function('glLoadIdentityDeformationMapSGIX', None, [GLbitfield], 'SGIX_polynomial_ffd')
PFNGLDEFORMATIONMAP3DSGIXPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)) # GL/glext.h:8308
PFNGLDEFORMATIONMAP3FSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)) # GL/glext.h:8309
PFNGLDEFORMSGIXPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:8310
PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:8311
# SGIX_reference_plane (GL/glext.h:8314)
GL_SGIX_reference_plane = 1 # GL/glext.h:8315
# GL/glext.h:8317
glReferencePlaneSGIX = _link_function('glReferencePlaneSGIX', None, [POINTER(GLdouble)], 'SGIX_reference_plane')
PFNGLREFERENCEPLANESGIXPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:8319
# SGIX_flush_raster (GL/glext.h:8322)
GL_SGIX_flush_raster = 1 # GL/glext.h:8323
# GL/glext.h:8325
glFlushRasterSGIX = _link_function('glFlushRasterSGIX', None, [], 'SGIX_flush_raster')
PFNGLFLUSHRASTERSGIXPROC = CFUNCTYPE(None) # GL/glext.h:8327
# SGIX_depth_texture (GL/glext.h:8330)
GL_SGIX_depth_texture = 1 # GL/glext.h:8331
# SGIS_fog_function (GL/glext.h:8334)
GL_SGIS_fog_function = 1 # GL/glext.h:8335
# GL/glext.h:8337
glFogFuncSGIS = _link_function('glFogFuncSGIS', None, [GLsizei, POINTER(GLfloat)], 'SGIS_fog_function')
# GL/glext.h:8338
glGetFogFuncSGIS = _link_function('glGetFogFuncSGIS', None, [POINTER(GLfloat)], 'SGIS_fog_function')
PFNGLFOGFUNCSGISPROC = CFUNCTYPE(None, GLsizei, POINTER(GLfloat)) # GL/glext.h:8340
PFNGLGETFOGFUNCSGISPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8341
# SGIX_fog_offset (GL/glext.h:8344)
GL_SGIX_fog_offset = 1 # GL/glext.h:8345
# HP_image_transform (GL/glext.h:8348)
GL_HP_image_transform = 1 # GL/glext.h:8349
# GL/glext.h:8351
glImageTransformParameteriHP = _link_function('glImageTransformParameteriHP', None, [GLenum, GLenum, GLint], 'HP_image_transform')
# GL/glext.h:8352
glImageTransformParameterfHP = _link_function('glImageTransformParameterfHP', None, [GLenum, GLenum, GLfloat], 'HP_image_transform')
# GL/glext.h:8353
glImageTransformParameterivHP = _link_function('glImageTransformParameterivHP', None, [GLenum, GLenum, POINTER(GLint)], 'HP_image_transform')
# GL/glext.h:8354
glImageTransformParameterfvHP = _link_function('glImageTransformParameterfvHP', None, [GLenum, GLenum, POINTER(GLfloat)], 'HP_image_transform')
# GL/glext.h:8355
glGetImageTransformParameterivHP = _link_function('glGetImageTransformParameterivHP', None, [GLenum, GLenum, POINTER(GLint)], 'HP_image_transform')
# GL/glext.h:8356
glGetImageTransformParameterfvHP = _link_function('glGetImageTransformParameterfvHP', None, [GLenum, GLenum, POINTER(GLfloat)], 'HP_image_transform')
PFNGLIMAGETRANSFORMPARAMETERIHPPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:8358
PFNGLIMAGETRANSFORMPARAMETERFHPPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:8359
PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8360
PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8361
PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8362
PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8363
# HP_convolution_border_modes (GL/glext.h:8366)
GL_HP_convolution_border_modes = 1 # GL/glext.h:8367
# SGIX_texture_add_env (GL/glext.h:8370)
GL_SGIX_texture_add_env = 1 # GL/glext.h:8371
# EXT_color_subtable (GL/glext.h:8374)
GL_EXT_color_subtable = 1 # GL/glext.h:8375
# GL/glext.h:8377
glColorSubTableEXT = _link_function('glColorSubTableEXT', None, [GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_color_subtable')
# GL/glext.h:8378
glCopyColorSubTableEXT = _link_function('glCopyColorSubTableEXT', None, [GLenum, GLsizei, GLint, GLint, GLsizei], 'EXT_color_subtable')
PFNGLCOLORSUBTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8380
PFNGLCOPYCOLORSUBTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLint, GLint, GLsizei) # GL/glext.h:8381
# PGI_vertex_hints (GL/glext.h:8384)
GL_PGI_vertex_hints = 1 # GL/glext.h:8385
# PGI_misc_hints (GL/glext.h:8388)
GL_PGI_misc_hints = 1 # GL/glext.h:8389
# GL/glext.h:8391
glHintPGI = _link_function('glHintPGI', None, [GLenum, GLint], 'PGI_misc_hints')
PFNGLHINTPGIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:8393
# EXT_paletted_texture (GL/glext.h:8396)
GL_EXT_paletted_texture = 1 # GL/glext.h:8397
# GL/glext.h:8399
glColorTableEXT = _link_function('glColorTableEXT', None, [GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_paletted_texture')
# GL/glext.h:8400
glGetColorTableEXT = _link_function('glGetColorTableEXT', None, [GLenum, GLenum, GLenum, POINTER(GLvoid)], 'EXT_paletted_texture')
# GL/glext.h:8401
glGetColorTableParameterivEXT = _link_function('glGetColorTableParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_paletted_texture')
# GL/glext.h:8402
glGetColorTableParameterfvEXT = _link_function('glGetColorTableParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_paletted_texture')
PFNGLCOLORTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8404
PFNGLGETCOLORTABLEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:8405
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8406
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8407
# EXT_clip_volume_hint (GL/glext.h:8410)
GL_EXT_clip_volume_hint = 1 # GL/glext.h:8411
# SGIX_list_priority (GL/glext.h:8414)
GL_SGIX_list_priority = 1 # GL/glext.h:8415
# GL/glext.h:8417
glGetListParameterfvSGIX = _link_function('glGetListParameterfvSGIX', None, [GLuint, GLenum, POINTER(GLfloat)], 'SGIX_list_priority')
# GL/glext.h:8418
glGetListParameterivSGIX = _link_function('glGetListParameterivSGIX', None, [GLuint, GLenum, POINTER(GLint)], 'SGIX_list_priority')
# GL/glext.h:8419
glListParameterfSGIX = _link_function('glListParameterfSGIX', None, [GLuint, GLenum, GLfloat], 'SGIX_list_priority')
# GL/glext.h:8420
glListParameterfvSGIX = _link_function('glListParameterfvSGIX', None, [GLuint, GLenum, POINTER(GLfloat)], 'SGIX_list_priority')
# GL/glext.h:8421
glListParameteriSGIX = _link_function('glListParameteriSGIX', None, [GLuint, GLenum, GLint], 'SGIX_list_priority')
# GL/glext.h:8422
glListParameterivSGIX = _link_function('glListParameterivSGIX', None, [GLuint, GLenum, POINTER(GLint)], 'SGIX_list_priority')
PFNGLGETLISTPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:8424
PFNGLGETLISTPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:8425
PFNGLLISTPARAMETERFSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, GLfloat) # GL/glext.h:8426
PFNGLLISTPARAMETERFVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:8427
PFNGLLISTPARAMETERISGIXPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:8428
PFNGLLISTPARAMETERIVSGIXPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:8429
# SGIX_ir_instrument1 (GL/glext.h:8432)
GL_SGIX_ir_instrument1 = 1 # GL/glext.h:8433
# SGIX_calligraphic_fragment (GL/glext.h:8436)
GL_SGIX_calligraphic_fragment = 1 # GL/glext.h:8437
# SGIX_texture_lod_bias (GL/glext.h:8440)
GL_SGIX_texture_lod_bias = 1 # GL/glext.h:8441
# SGIX_shadow_ambient (GL/glext.h:8444)
GL_SGIX_shadow_ambient = 1 # GL/glext.h:8445
# EXT_index_texture (GL/glext.h:8448)
GL_EXT_index_texture = 1 # GL/glext.h:8449
# EXT_index_material (GL/glext.h:8452)
GL_EXT_index_material = 1 # GL/glext.h:8453
# GL/glext.h:8455
glIndexMaterialEXT = _link_function('glIndexMaterialEXT', None, [GLenum, GLenum], 'EXT_index_material')
PFNGLINDEXMATERIALEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:8457
# EXT_index_func (GL/glext.h:8460)
GL_EXT_index_func = 1 # GL/glext.h:8461
# GL/glext.h:8463
glIndexFuncEXT = _link_function('glIndexFuncEXT', None, [GLenum, GLclampf], 'EXT_index_func')
PFNGLINDEXFUNCEXTPROC = CFUNCTYPE(None, GLenum, GLclampf) # GL/glext.h:8465
# EXT_index_array_formats (GL/glext.h:8468)
GL_EXT_index_array_formats = 1 # GL/glext.h:8469
# EXT_compiled_vertex_array (GL/glext.h:8472)
GL_EXT_compiled_vertex_array = 1 # GL/glext.h:8473
# GL/glext.h:8475
glLockArraysEXT = _link_function('glLockArraysEXT', None, [GLint, GLsizei], 'EXT_compiled_vertex_array')
# GL/glext.h:8476
glUnlockArraysEXT = _link_function('glUnlockArraysEXT', None, [], 'EXT_compiled_vertex_array')
PFNGLLOCKARRAYSEXTPROC = CFUNCTYPE(None, GLint, GLsizei) # GL/glext.h:8478
PFNGLUNLOCKARRAYSEXTPROC = CFUNCTYPE(None) # GL/glext.h:8479
# EXT_cull_vertex (GL/glext.h:8482)
GL_EXT_cull_vertex = 1 # GL/glext.h:8483
# GL/glext.h:8485
glCullParameterdvEXT = _link_function('glCullParameterdvEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_cull_vertex')
# GL/glext.h:8486
glCullParameterfvEXT = _link_function('glCullParameterfvEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_cull_vertex')
PFNGLCULLPARAMETERDVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:8488
PFNGLCULLPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8489
# SGIX_ycrcb (GL/glext.h:8492)
GL_SGIX_ycrcb = 1 # GL/glext.h:8493
# SGIX_fragment_lighting (GL/glext.h:8496)
GL_SGIX_fragment_lighting = 1 # GL/glext.h:8497
# GL/glext.h:8499
glFragmentColorMaterialSGIX = _link_function('glFragmentColorMaterialSGIX', None, [GLenum, GLenum], 'SGIX_fragment_lighting')
# GL/glext.h:8500
glFragmentLightfSGIX = _link_function('glFragmentLightfSGIX', None, [GLenum, GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:8501
glFragmentLightfvSGIX = _link_function('glFragmentLightfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:8502
glFragmentLightiSGIX = _link_function('glFragmentLightiSGIX', None, [GLenum, GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:8503
glFragmentLightivSGIX = _link_function('glFragmentLightivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:8504
glFragmentLightModelfSGIX = _link_function('glFragmentLightModelfSGIX', None, [GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:8505
glFragmentLightModelfvSGIX = _link_function('glFragmentLightModelfvSGIX', None, [GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:8506
glFragmentLightModeliSGIX = _link_function('glFragmentLightModeliSGIX', None, [GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:8507
glFragmentLightModelivSGIX = _link_function('glFragmentLightModelivSGIX', None, [GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:8508
glFragmentMaterialfSGIX = _link_function('glFragmentMaterialfSGIX', None, [GLenum, GLenum, GLfloat], 'SGIX_fragment_lighting')
# GL/glext.h:8509
glFragmentMaterialfvSGIX = _link_function('glFragmentMaterialfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:8510
glFragmentMaterialiSGIX = _link_function('glFragmentMaterialiSGIX', None, [GLenum, GLenum, GLint], 'SGIX_fragment_lighting')
# GL/glext.h:8511
glFragmentMaterialivSGIX = _link_function('glFragmentMaterialivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:8512
glGetFragmentLightfvSGIX = _link_function('glGetFragmentLightfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:8513
glGetFragmentLightivSGIX = _link_function('glGetFragmentLightivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:8514
glGetFragmentMaterialfvSGIX = _link_function('glGetFragmentMaterialfvSGIX', None, [GLenum, GLenum, POINTER(GLfloat)], 'SGIX_fragment_lighting')
# GL/glext.h:8515
glGetFragmentMaterialivSGIX = _link_function('glGetFragmentMaterialivSGIX', None, [GLenum, GLenum, POINTER(GLint)], 'SGIX_fragment_lighting')
# GL/glext.h:8516
glLightEnviSGIX = _link_function('glLightEnviSGIX', None, [GLenum, GLint], 'SGIX_fragment_lighting')
PFNGLFRAGMENTCOLORMATERIALSGIXPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:8518
PFNGLFRAGMENTLIGHTFSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:8519
PFNGLFRAGMENTLIGHTFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8520
PFNGLFRAGMENTLIGHTISGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:8521
PFNGLFRAGMENTLIGHTIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8522
PFNGLFRAGMENTLIGHTMODELFSGIXPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:8523
PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:8524
PFNGLFRAGMENTLIGHTMODELISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:8525
PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:8526
PFNGLFRAGMENTMATERIALFSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:8527
PFNGLFRAGMENTMATERIALFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8528
PFNGLFRAGMENTMATERIALISGIXPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:8529
PFNGLFRAGMENTMATERIALIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8530
PFNGLGETFRAGMENTLIGHTFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8531
PFNGLGETFRAGMENTLIGHTIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8532
PFNGLGETFRAGMENTMATERIALFVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8533
PFNGLGETFRAGMENTMATERIALIVSGIXPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8534
PFNGLLIGHTENVISGIXPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:8535
# IBM_rasterpos_clip (GL/glext.h:8538)
GL_IBM_rasterpos_clip = 1 # GL/glext.h:8539
# HP_texture_lighting (GL/glext.h:8542)
GL_HP_texture_lighting = 1 # GL/glext.h:8543
# EXT_draw_range_elements (GL/glext.h:8546)
GL_EXT_draw_range_elements = 1 # GL/glext.h:8547
# GL/glext.h:8549
glDrawRangeElementsEXT = _link_function('glDrawRangeElementsEXT', None, [GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)], 'EXT_draw_range_elements')
PFNGLDRAWRANGEELEMENTSEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:8551
# WIN_phong_shading (GL/glext.h:8554)
GL_WIN_phong_shading = 1 # GL/glext.h:8555
# WIN_specular_fog (GL/glext.h:8558)
GL_WIN_specular_fog = 1 # GL/glext.h:8559
# EXT_light_texture (GL/glext.h:8562)
GL_EXT_light_texture = 1 # GL/glext.h:8563
# GL/glext.h:8565
glApplyTextureEXT = _link_function('glApplyTextureEXT', None, [GLenum], 'EXT_light_texture')
# GL/glext.h:8566
glTextureLightEXT = _link_function('glTextureLightEXT', None, [GLenum], 'EXT_light_texture')
# GL/glext.h:8567
glTextureMaterialEXT = _link_function('glTextureMaterialEXT', None, [GLenum, GLenum], 'EXT_light_texture')
PFNGLAPPLYTEXTUREEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8569
PFNGLTEXTURELIGHTEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8570
PFNGLTEXTUREMATERIALEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:8571
# SGIX_blend_alpha_minmax (GL/glext.h:8574)
GL_SGIX_blend_alpha_minmax = 1 # GL/glext.h:8575
# EXT_bgra (GL/glext.h:8578)
GL_EXT_bgra = 1 # GL/glext.h:8579
# SGIX_async (GL/glext.h:8582)
GL_SGIX_async = 1 # GL/glext.h:8583
# GL/glext.h:8585
glAsyncMarkerSGIX = _link_function('glAsyncMarkerSGIX', None, [GLuint], 'SGIX_async')
# GL/glext.h:8586
glFinishAsyncSGIX = _link_function('glFinishAsyncSGIX', GLint, [POINTER(GLuint)], 'SGIX_async')
# GL/glext.h:8587
glPollAsyncSGIX = _link_function('glPollAsyncSGIX', GLint, [POINTER(GLuint)], 'SGIX_async')
# GL/glext.h:8588
glGenAsyncMarkersSGIX = _link_function('glGenAsyncMarkersSGIX', GLuint, [GLsizei], 'SGIX_async')
# GL/glext.h:8589
glDeleteAsyncMarkersSGIX = _link_function('glDeleteAsyncMarkersSGIX', None, [GLuint, GLsizei], 'SGIX_async')
# GL/glext.h:8590
glIsAsyncMarkerSGIX = _link_function('glIsAsyncMarkerSGIX', GLboolean, [GLuint], 'SGIX_async')
PFNGLASYNCMARKERSGIXPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:8592
PFNGLFINISHASYNCSGIXPROC = CFUNCTYPE(GLint, POINTER(GLuint)) # GL/glext.h:8593
PFNGLPOLLASYNCSGIXPROC = CFUNCTYPE(GLint, POINTER(GLuint)) # GL/glext.h:8594
PFNGLGENASYNCMARKERSSGIXPROC = CFUNCTYPE(GLuint, GLsizei) # GL/glext.h:8595
PFNGLDELETEASYNCMARKERSSGIXPROC = CFUNCTYPE(None, GLuint, GLsizei) # GL/glext.h:8596
PFNGLISASYNCMARKERSGIXPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:8597
# SGIX_async_pixel (GL/glext.h:8600)
GL_SGIX_async_pixel = 1 # GL/glext.h:8601
# SGIX_async_histogram (GL/glext.h:8604)
GL_SGIX_async_histogram = 1 # GL/glext.h:8605
# INTEL_parallel_arrays (GL/glext.h:8608)
GL_INTEL_parallel_arrays = 1 # GL/glext.h:8609
# GL/glext.h:8611
glVertexPointervINTEL = _link_function('glVertexPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:8612
glNormalPointervINTEL = _link_function('glNormalPointervINTEL', None, [GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:8613
glColorPointervINTEL = _link_function('glColorPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
# GL/glext.h:8614
glTexCoordPointervINTEL = _link_function('glTexCoordPointervINTEL', None, [GLint, GLenum, POINTER(POINTER(GLvoid))], 'INTEL_parallel_arrays')
PFNGLVERTEXPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8616
PFNGLNORMALPOINTERVINTELPROC = CFUNCTYPE(None, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8617
PFNGLCOLORPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8618
PFNGLTEXCOORDPOINTERVINTELPROC = CFUNCTYPE(None, GLint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:8619
# HP_occlusion_test (GL/glext.h:8622)
GL_HP_occlusion_test = 1 # GL/glext.h:8623
# EXT_pixel_transform (GL/glext.h:8626)
GL_EXT_pixel_transform = 1 # GL/glext.h:8627
# GL/glext.h:8629
glPixelTransformParameteriEXT = _link_function('glPixelTransformParameteriEXT', None, [GLenum, GLenum, GLint], 'EXT_pixel_transform')
# GL/glext.h:8630
glPixelTransformParameterfEXT = _link_function('glPixelTransformParameterfEXT', None, [GLenum, GLenum, GLfloat], 'EXT_pixel_transform')
# GL/glext.h:8631
glPixelTransformParameterivEXT = _link_function('glPixelTransformParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_pixel_transform')
# GL/glext.h:8632
glPixelTransformParameterfvEXT = _link_function('glPixelTransformParameterfvEXT', None, [GLenum, GLenum, POINTER(GLfloat)], 'EXT_pixel_transform')
PFNGLPIXELTRANSFORMPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:8634
PFNGLPIXELTRANSFORMPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLfloat) # GL/glext.h:8635
PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:8636
PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:8637
# EXT_pixel_transform_color_table (GL/glext.h:8640)
GL_EXT_pixel_transform_color_table = 1 # GL/glext.h:8641
# EXT_shared_texture_palette (GL/glext.h:8644)
GL_EXT_shared_texture_palette = 1 # GL/glext.h:8645
# EXT_separate_specular_color (GL/glext.h:8648)
GL_EXT_separate_specular_color = 1 # GL/glext.h:8649
# EXT_secondary_color (GL/glext.h:8652)
GL_EXT_secondary_color = 1 # GL/glext.h:8653
# GL/glext.h:8655
glSecondaryColor3bEXT = _link_function('glSecondaryColor3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_secondary_color')
# GL/glext.h:8656
glSecondaryColor3bvEXT = _link_function('glSecondaryColor3bvEXT', None, [POINTER(GLbyte)], 'EXT_secondary_color')
# GL/glext.h:8657
glSecondaryColor3dEXT = _link_function('glSecondaryColor3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_secondary_color')
# GL/glext.h:8658
glSecondaryColor3dvEXT = _link_function('glSecondaryColor3dvEXT', None, [POINTER(GLdouble)], 'EXT_secondary_color')
# GL/glext.h:8659
glSecondaryColor3fEXT = _link_function('glSecondaryColor3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_secondary_color')
# GL/glext.h:8660
glSecondaryColor3fvEXT = _link_function('glSecondaryColor3fvEXT', None, [POINTER(GLfloat)], 'EXT_secondary_color')
# GL/glext.h:8661
glSecondaryColor3iEXT = _link_function('glSecondaryColor3iEXT', None, [GLint, GLint, GLint], 'EXT_secondary_color')
# GL/glext.h:8662
glSecondaryColor3ivEXT = _link_function('glSecondaryColor3ivEXT', None, [POINTER(GLint)], 'EXT_secondary_color')
# GL/glext.h:8663
glSecondaryColor3sEXT = _link_function('glSecondaryColor3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_secondary_color')
# GL/glext.h:8664
glSecondaryColor3svEXT = _link_function('glSecondaryColor3svEXT', None, [POINTER(GLshort)], 'EXT_secondary_color')
# GL/glext.h:8665
glSecondaryColor3ubEXT = _link_function('glSecondaryColor3ubEXT', None, [GLubyte, GLubyte, GLubyte], 'EXT_secondary_color')
# GL/glext.h:8666
glSecondaryColor3ubvEXT = _link_function('glSecondaryColor3ubvEXT', None, [POINTER(GLubyte)], 'EXT_secondary_color')
# GL/glext.h:8667
glSecondaryColor3uiEXT = _link_function('glSecondaryColor3uiEXT', None, [GLuint, GLuint, GLuint], 'EXT_secondary_color')
# GL/glext.h:8668
glSecondaryColor3uivEXT = _link_function('glSecondaryColor3uivEXT', None, [POINTER(GLuint)], 'EXT_secondary_color')
# GL/glext.h:8669
glSecondaryColor3usEXT = _link_function('glSecondaryColor3usEXT', None, [GLushort, GLushort, GLushort], 'EXT_secondary_color')
# GL/glext.h:8670
glSecondaryColor3usvEXT = _link_function('glSecondaryColor3usvEXT', None, [POINTER(GLushort)], 'EXT_secondary_color')
# GL/glext.h:8671
glSecondaryColorPointerEXT = _link_function('glSecondaryColorPointerEXT', None, [GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_secondary_color')
PFNGLSECONDARYCOLOR3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:8673
PFNGLSECONDARYCOLOR3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:8674
PFNGLSECONDARYCOLOR3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:8675
PFNGLSECONDARYCOLOR3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:8676
PFNGLSECONDARYCOLOR3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:8677
PFNGLSECONDARYCOLOR3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8678
PFNGLSECONDARYCOLOR3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:8679
PFNGLSECONDARYCOLOR3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:8680
PFNGLSECONDARYCOLOR3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:8681
PFNGLSECONDARYCOLOR3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:8682
PFNGLSECONDARYCOLOR3UBEXTPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte) # GL/glext.h:8683
PFNGLSECONDARYCOLOR3UBVEXTPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:8684
PFNGLSECONDARYCOLOR3UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:8685
PFNGLSECONDARYCOLOR3UIVEXTPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:8686
PFNGLSECONDARYCOLOR3USEXTPROC = CFUNCTYPE(None, GLushort, GLushort, GLushort) # GL/glext.h:8687
PFNGLSECONDARYCOLOR3USVEXTPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:8688
PFNGLSECONDARYCOLORPOINTEREXTPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8689
# EXT_texture_perturb_normal (GL/glext.h:8692)
GL_EXT_texture_perturb_normal = 1 # GL/glext.h:8693
# GL/glext.h:8695
glTextureNormalEXT = _link_function('glTextureNormalEXT', None, [GLenum], 'EXT_texture_perturb_normal')
PFNGLTEXTURENORMALEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:8697
# EXT_multi_draw_arrays (GL/glext.h:8700)
GL_EXT_multi_draw_arrays = 1 # GL/glext.h:8701
# GL/glext.h:8703
glMultiDrawArraysEXT = _link_function('glMultiDrawArraysEXT', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'EXT_multi_draw_arrays')
# GL/glext.h:8704
glMultiDrawElementsEXT = _link_function('glMultiDrawElementsEXT', None, [GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei], 'EXT_multi_draw_arrays')
PFNGLMULTIDRAWARRAYSEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:8706
PFNGLMULTIDRAWELEMENTSEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei) # GL/glext.h:8707
# EXT_fog_coord (GL/glext.h:8710)
GL_EXT_fog_coord = 1 # GL/glext.h:8711
# GL/glext.h:8713
glFogCoordfEXT = _link_function('glFogCoordfEXT', None, [GLfloat], 'EXT_fog_coord')
# GL/glext.h:8714
glFogCoordfvEXT = _link_function('glFogCoordfvEXT', None, [POINTER(GLfloat)], 'EXT_fog_coord')
# GL/glext.h:8715
glFogCoorddEXT = _link_function('glFogCoorddEXT', None, [GLdouble], 'EXT_fog_coord')
# GL/glext.h:8716
glFogCoorddvEXT = _link_function('glFogCoorddvEXT', None, [POINTER(GLdouble)], 'EXT_fog_coord')
# GL/glext.h:8717
glFogCoordPointerEXT = _link_function('glFogCoordPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_fog_coord')
PFNGLFOGCOORDFEXTPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:8719
PFNGLFOGCOORDFVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8720
PFNGLFOGCOORDDEXTPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:8721
PFNGLFOGCOORDDVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:8722
PFNGLFOGCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8723
# REND_screen_coordinates (GL/glext.h:8726)
GL_REND_screen_coordinates = 1 # GL/glext.h:8727
# EXT_coordinate_frame (GL/glext.h:8730)
GL_EXT_coordinate_frame = 1 # GL/glext.h:8731
# GL/glext.h:8733
glTangent3bEXT = _link_function('glTangent3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_coordinate_frame')
# GL/glext.h:8734
glTangent3bvEXT = _link_function('glTangent3bvEXT', None, [POINTER(GLbyte)], 'EXT_coordinate_frame')
# GL/glext.h:8735
glTangent3dEXT = _link_function('glTangent3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_coordinate_frame')
# GL/glext.h:8736
glTangent3dvEXT = _link_function('glTangent3dvEXT', None, [POINTER(GLdouble)], 'EXT_coordinate_frame')
# GL/glext.h:8737
glTangent3fEXT = _link_function('glTangent3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_coordinate_frame')
# GL/glext.h:8738
glTangent3fvEXT = _link_function('glTangent3fvEXT', None, [POINTER(GLfloat)], 'EXT_coordinate_frame')
# GL/glext.h:8739
glTangent3iEXT = _link_function('glTangent3iEXT', None, [GLint, GLint, GLint], 'EXT_coordinate_frame')
# GL/glext.h:8740
glTangent3ivEXT = _link_function('glTangent3ivEXT', None, [POINTER(GLint)], 'EXT_coordinate_frame')
# GL/glext.h:8741
glTangent3sEXT = _link_function('glTangent3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_coordinate_frame')
# GL/glext.h:8742
glTangent3svEXT = _link_function('glTangent3svEXT', None, [POINTER(GLshort)], 'EXT_coordinate_frame')
# GL/glext.h:8743
glBinormal3bEXT = _link_function('glBinormal3bEXT', None, [GLbyte, GLbyte, GLbyte], 'EXT_coordinate_frame')
# GL/glext.h:8744
glBinormal3bvEXT = _link_function('glBinormal3bvEXT', None, [POINTER(GLbyte)], 'EXT_coordinate_frame')
# GL/glext.h:8745
glBinormal3dEXT = _link_function('glBinormal3dEXT', None, [GLdouble, GLdouble, GLdouble], 'EXT_coordinate_frame')
# GL/glext.h:8746
glBinormal3dvEXT = _link_function('glBinormal3dvEXT', None, [POINTER(GLdouble)], 'EXT_coordinate_frame')
# GL/glext.h:8747
glBinormal3fEXT = _link_function('glBinormal3fEXT', None, [GLfloat, GLfloat, GLfloat], 'EXT_coordinate_frame')
# GL/glext.h:8748
glBinormal3fvEXT = _link_function('glBinormal3fvEXT', None, [POINTER(GLfloat)], 'EXT_coordinate_frame')
# GL/glext.h:8749
glBinormal3iEXT = _link_function('glBinormal3iEXT', None, [GLint, GLint, GLint], 'EXT_coordinate_frame')
# GL/glext.h:8750
glBinormal3ivEXT = _link_function('glBinormal3ivEXT', None, [POINTER(GLint)], 'EXT_coordinate_frame')
# GL/glext.h:8751
glBinormal3sEXT = _link_function('glBinormal3sEXT', None, [GLshort, GLshort, GLshort], 'EXT_coordinate_frame')
# GL/glext.h:8752
glBinormal3svEXT = _link_function('glBinormal3svEXT', None, [POINTER(GLshort)], 'EXT_coordinate_frame')
# GL/glext.h:8753
glTangentPointerEXT = _link_function('glTangentPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_coordinate_frame')
# GL/glext.h:8754
glBinormalPointerEXT = _link_function('glBinormalPointerEXT', None, [GLenum, GLsizei, POINTER(GLvoid)], 'EXT_coordinate_frame')
PFNGLTANGENT3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:8756
PFNGLTANGENT3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:8757
PFNGLTANGENT3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:8758
PFNGLTANGENT3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:8759
PFNGLTANGENT3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:8760
PFNGLTANGENT3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8761
PFNGLTANGENT3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:8762
PFNGLTANGENT3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:8763
PFNGLTANGENT3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:8764
PFNGLTANGENT3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:8765
PFNGLBINORMAL3BEXTPROC = CFUNCTYPE(None, GLbyte, GLbyte, GLbyte) # GL/glext.h:8766
PFNGLBINORMAL3BVEXTPROC = CFUNCTYPE(None, POINTER(GLbyte)) # GL/glext.h:8767
PFNGLBINORMAL3DEXTPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:8768
PFNGLBINORMAL3DVEXTPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:8769
PFNGLBINORMAL3FEXTPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:8770
PFNGLBINORMAL3FVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8771
PFNGLBINORMAL3IEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:8772
PFNGLBINORMAL3IVEXTPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:8773
PFNGLBINORMAL3SEXTPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:8774
PFNGLBINORMAL3SVEXTPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:8775
PFNGLTANGENTPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8776
PFNGLBINORMALPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8777
# EXT_texture_env_combine (GL/glext.h:8780)
GL_EXT_texture_env_combine = 1 # GL/glext.h:8781
# APPLE_specular_vector (GL/glext.h:8784)
GL_APPLE_specular_vector = 1 # GL/glext.h:8785
# APPLE_transform_hint (GL/glext.h:8788)
GL_APPLE_transform_hint = 1 # GL/glext.h:8789
# SGIX_fog_scale (GL/glext.h:8792)
GL_SGIX_fog_scale = 1 # GL/glext.h:8793
# SUNX_constant_data (GL/glext.h:8796)
GL_SUNX_constant_data = 1 # GL/glext.h:8797
# GL/glext.h:8799
glFinishTextureSUNX = _link_function('glFinishTextureSUNX', None, [], 'SUNX_constant_data')
PFNGLFINISHTEXTURESUNXPROC = CFUNCTYPE(None) # GL/glext.h:8801
# SUN_global_alpha (GL/glext.h:8804)
GL_SUN_global_alpha = 1 # GL/glext.h:8805
# GL/glext.h:8807
glGlobalAlphaFactorbSUN = _link_function('glGlobalAlphaFactorbSUN', None, [GLbyte], 'SUN_global_alpha')
# GL/glext.h:8808
glGlobalAlphaFactorsSUN = _link_function('glGlobalAlphaFactorsSUN', None, [GLshort], 'SUN_global_alpha')
# GL/glext.h:8809
glGlobalAlphaFactoriSUN = _link_function('glGlobalAlphaFactoriSUN', None, [GLint], 'SUN_global_alpha')
# GL/glext.h:8810
glGlobalAlphaFactorfSUN = _link_function('glGlobalAlphaFactorfSUN', None, [GLfloat], 'SUN_global_alpha')
# GL/glext.h:8811
glGlobalAlphaFactordSUN = _link_function('glGlobalAlphaFactordSUN', None, [GLdouble], 'SUN_global_alpha')
# GL/glext.h:8812
glGlobalAlphaFactorubSUN = _link_function('glGlobalAlphaFactorubSUN', None, [GLubyte], 'SUN_global_alpha')
# GL/glext.h:8813
glGlobalAlphaFactorusSUN = _link_function('glGlobalAlphaFactorusSUN', None, [GLushort], 'SUN_global_alpha')
# GL/glext.h:8814
glGlobalAlphaFactoruiSUN = _link_function('glGlobalAlphaFactoruiSUN', None, [GLuint], 'SUN_global_alpha')
PFNGLGLOBALALPHAFACTORBSUNPROC = CFUNCTYPE(None, GLbyte) # GL/glext.h:8816
PFNGLGLOBALALPHAFACTORSSUNPROC = CFUNCTYPE(None, GLshort) # GL/glext.h:8817
PFNGLGLOBALALPHAFACTORISUNPROC = CFUNCTYPE(None, GLint) # GL/glext.h:8818
PFNGLGLOBALALPHAFACTORFSUNPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:8819
PFNGLGLOBALALPHAFACTORDSUNPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:8820
PFNGLGLOBALALPHAFACTORUBSUNPROC = CFUNCTYPE(None, GLubyte) # GL/glext.h:8821
PFNGLGLOBALALPHAFACTORUSSUNPROC = CFUNCTYPE(None, GLushort) # GL/glext.h:8822
PFNGLGLOBALALPHAFACTORUISUNPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:8823
# SUN_triangle_list (GL/glext.h:8826)
GL_SUN_triangle_list = 1 # GL/glext.h:8827
# GL/glext.h:8829
glReplacementCodeuiSUN = _link_function('glReplacementCodeuiSUN', None, [GLuint], 'SUN_triangle_list')
# GL/glext.h:8830
glReplacementCodeusSUN = _link_function('glReplacementCodeusSUN', None, [GLushort], 'SUN_triangle_list')
# GL/glext.h:8831
glReplacementCodeubSUN = _link_function('glReplacementCodeubSUN', None, [GLubyte], 'SUN_triangle_list')
# GL/glext.h:8832
glReplacementCodeuivSUN = _link_function('glReplacementCodeuivSUN', None, [POINTER(GLuint)], 'SUN_triangle_list')
# GL/glext.h:8833
glReplacementCodeusvSUN = _link_function('glReplacementCodeusvSUN', None, [POINTER(GLushort)], 'SUN_triangle_list')
# GL/glext.h:8834
glReplacementCodeubvSUN = _link_function('glReplacementCodeubvSUN', None, [POINTER(GLubyte)], 'SUN_triangle_list')
# GL/glext.h:8835
glReplacementCodePointerSUN = _link_function('glReplacementCodePointerSUN', None, [GLenum, GLsizei, POINTER(POINTER(GLvoid))], 'SUN_triangle_list')
PFNGLREPLACEMENTCODEUISUNPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:8837
PFNGLREPLACEMENTCODEUSSUNPROC = CFUNCTYPE(None, GLushort) # GL/glext.h:8838
PFNGLREPLACEMENTCODEUBSUNPROC = CFUNCTYPE(None, GLubyte) # GL/glext.h:8839
PFNGLREPLACEMENTCODEUIVSUNPROC = CFUNCTYPE(None, POINTER(GLuint)) # GL/glext.h:8840
PFNGLREPLACEMENTCODEUSVSUNPROC = CFUNCTYPE(None, POINTER(GLushort)) # GL/glext.h:8841
PFNGLREPLACEMENTCODEUBVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte)) # GL/glext.h:8842
PFNGLREPLACEMENTCODEPOINTERSUNPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(POINTER(GLvoid))) # GL/glext.h:8843
# SUN_vertex (GL/glext.h:8846)
GL_SUN_vertex = 1 # GL/glext.h:8847
# GL/glext.h:8849
glColor4ubVertex2fSUN = _link_function('glColor4ubVertex2fSUN', None, [GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8850
glColor4ubVertex2fvSUN = _link_function('glColor4ubVertex2fvSUN', None, [POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8851
glColor4ubVertex3fSUN = _link_function('glColor4ubVertex3fSUN', None, [GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8852
glColor4ubVertex3fvSUN = _link_function('glColor4ubVertex3fvSUN', None, [POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8853
glColor3fVertex3fSUN = _link_function('glColor3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8854
glColor3fVertex3fvSUN = _link_function('glColor3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8855
glNormal3fVertex3fSUN = _link_function('glNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8856
glNormal3fVertex3fvSUN = _link_function('glNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8857
glColor4fNormal3fVertex3fSUN = _link_function('glColor4fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8858
glColor4fNormal3fVertex3fvSUN = _link_function('glColor4fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8859
glTexCoord2fVertex3fSUN = _link_function('glTexCoord2fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8860
glTexCoord2fVertex3fvSUN = _link_function('glTexCoord2fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8861
glTexCoord4fVertex4fSUN = _link_function('glTexCoord4fVertex4fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8862
glTexCoord4fVertex4fvSUN = _link_function('glTexCoord4fVertex4fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8863
glTexCoord2fColor4ubVertex3fSUN = _link_function('glTexCoord2fColor4ubVertex3fSUN', None, [GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8864
glTexCoord2fColor4ubVertex3fvSUN = _link_function('glTexCoord2fColor4ubVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8865
glTexCoord2fColor3fVertex3fSUN = _link_function('glTexCoord2fColor3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8866
glTexCoord2fColor3fVertex3fvSUN = _link_function('glTexCoord2fColor3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8867
glTexCoord2fNormal3fVertex3fSUN = _link_function('glTexCoord2fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8868
glTexCoord2fNormal3fVertex3fvSUN = _link_function('glTexCoord2fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8869
glTexCoord2fColor4fNormal3fVertex3fSUN = _link_function('glTexCoord2fColor4fNormal3fVertex3fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8870
glTexCoord2fColor4fNormal3fVertex3fvSUN = _link_function('glTexCoord2fColor4fNormal3fVertex3fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8871
glTexCoord4fColor4fNormal3fVertex4fSUN = _link_function('glTexCoord4fColor4fNormal3fVertex4fSUN', None, [GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8872
glTexCoord4fColor4fNormal3fVertex4fvSUN = _link_function('glTexCoord4fColor4fNormal3fVertex4fvSUN', None, [POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8873
glReplacementCodeuiVertex3fSUN = _link_function('glReplacementCodeuiVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8874
glReplacementCodeuiVertex3fvSUN = _link_function('glReplacementCodeuiVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8875
glReplacementCodeuiColor4ubVertex3fSUN = _link_function('glReplacementCodeuiColor4ubVertex3fSUN', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8876
glReplacementCodeuiColor4ubVertex3fvSUN = _link_function('glReplacementCodeuiColor4ubVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLubyte), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8877
glReplacementCodeuiColor3fVertex3fSUN = _link_function('glReplacementCodeuiColor3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8878
glReplacementCodeuiColor3fVertex3fvSUN = _link_function('glReplacementCodeuiColor3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8879
glReplacementCodeuiNormal3fVertex3fSUN = _link_function('glReplacementCodeuiNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8880
glReplacementCodeuiNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8881
glReplacementCodeuiColor4fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiColor4fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8882
glReplacementCodeuiColor4fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiColor4fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8883
glReplacementCodeuiTexCoord2fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8884
glReplacementCodeuiTexCoord2fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8885
glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8886
glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
# GL/glext.h:8887
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = _link_function('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat], 'SUN_vertex')
# GL/glext.h:8888
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = _link_function('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN', None, [POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'SUN_vertex')
PFNGLCOLOR4UBVERTEX2FSUNPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat) # GL/glext.h:8890
PFNGLCOLOR4UBVERTEX2FVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:8891
PFNGLCOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:8892
PFNGLCOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:8893
PFNGLCOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8894
PFNGLCOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8895
PFNGLNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8896
PFNGLNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8897
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8898
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8899
PFNGLTEXCOORD2FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8900
PFNGLTEXCOORD2FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8901
PFNGLTEXCOORD4FVERTEX4FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8902
PFNGLTEXCOORD4FVERTEX4FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8903
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:8904
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:8905
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8906
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8907
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8908
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8909
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8910
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8911
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8912
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC = CFUNCTYPE(None, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8913
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:8914
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat)) # GL/glext.h:8915
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat) # GL/glext.h:8916
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:8917
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8918
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8919
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8920
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8921
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8922
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8923
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8924
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8925
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8926
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8927
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:8928
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFUNCTYPE(None, POINTER(GLuint), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:8929
# EXT_blend_func_separate (GL/glext.h:8932)
GL_EXT_blend_func_separate = 1 # GL/glext.h:8933
# GL/glext.h:8935
glBlendFuncSeparateEXT = _link_function('glBlendFuncSeparateEXT', None, [GLenum, GLenum, GLenum, GLenum], 'EXT_blend_func_separate')
PFNGLBLENDFUNCSEPARATEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:8937
# INGR_blend_func_separate (GL/glext.h:8940)
GL_INGR_blend_func_separate = 1 # GL/glext.h:8941
# GL/glext.h:8943
glBlendFuncSeparateINGR = _link_function('glBlendFuncSeparateINGR', None, [GLenum, GLenum, GLenum, GLenum], 'INGR_blend_func_separate')
PFNGLBLENDFUNCSEPARATEINGRPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:8945
# INGR_color_clamp (GL/glext.h:8948)
GL_INGR_color_clamp = 1 # GL/glext.h:8949
# INGR_interlace_read (GL/glext.h:8952)
GL_INGR_interlace_read = 1 # GL/glext.h:8953
# EXT_stencil_wrap (GL/glext.h:8956)
GL_EXT_stencil_wrap = 1 # GL/glext.h:8957
# EXT_422_pixels (GL/glext.h:8960)
GL_EXT_422_pixels = 1 # GL/glext.h:8961
# NV_texgen_reflection (GL/glext.h:8964)
GL_NV_texgen_reflection = 1 # GL/glext.h:8965
# SUN_convolution_border_modes (GL/glext.h:8968)
GL_SUN_convolution_border_modes = 1 # GL/glext.h:8969
# EXT_texture_env_add (GL/glext.h:8972)
GL_EXT_texture_env_add = 1 # GL/glext.h:8973
# EXT_texture_lod_bias (GL/glext.h:8976)
GL_EXT_texture_lod_bias = 1 # GL/glext.h:8977
# EXT_texture_filter_anisotropic (GL/glext.h:8980)
GL_EXT_texture_filter_anisotropic = 1 # GL/glext.h:8981
# EXT_vertex_weighting (GL/glext.h:8984)
GL_EXT_vertex_weighting = 1 # GL/glext.h:8985
# GL/glext.h:8987
glVertexWeightfEXT = _link_function('glVertexWeightfEXT', None, [GLfloat], 'EXT_vertex_weighting')
# GL/glext.h:8988
glVertexWeightfvEXT = _link_function('glVertexWeightfvEXT', None, [POINTER(GLfloat)], 'EXT_vertex_weighting')
# GL/glext.h:8989
glVertexWeightPointerEXT = _link_function('glVertexWeightPointerEXT', None, [GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_vertex_weighting')
PFNGLVERTEXWEIGHTFEXTPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:8991
PFNGLVERTEXWEIGHTFVEXTPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:8992
PFNGLVERTEXWEIGHTPOINTEREXTPROC = CFUNCTYPE(None, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:8993
# NV_light_max_exponent (GL/glext.h:8996)
GL_NV_light_max_exponent = 1 # GL/glext.h:8997
# NV_vertex_array_range (GL/glext.h:9000)
GL_NV_vertex_array_range = 1 # GL/glext.h:9001
# GL/glext.h:9003
glFlushVertexArrayRangeNV = _link_function('glFlushVertexArrayRangeNV', None, [], 'NV_vertex_array_range')
# GL/glext.h:9004
glVertexArrayRangeNV = _link_function('glVertexArrayRangeNV', None, [GLsizei, POINTER(GLvoid)], 'NV_vertex_array_range')
PFNGLFLUSHVERTEXARRAYRANGENVPROC = CFUNCTYPE(None) # GL/glext.h:9006
PFNGLVERTEXARRAYRANGENVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:9007
# NV_register_combiners (GL/glext.h:9010)
GL_NV_register_combiners = 1 # GL/glext.h:9011
# GL/glext.h:9013
glCombinerParameterfvNV = _link_function('glCombinerParameterfvNV', None, [GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:9014
glCombinerParameterfNV = _link_function('glCombinerParameterfNV', None, [GLenum, GLfloat], 'NV_register_combiners')
# GL/glext.h:9015
glCombinerParameterivNV = _link_function('glCombinerParameterivNV', None, [GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:9016
glCombinerParameteriNV = _link_function('glCombinerParameteriNV', None, [GLenum, GLint], 'NV_register_combiners')
# GL/glext.h:9017
glCombinerInputNV = _link_function('glCombinerInputNV', None, [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum], 'NV_register_combiners')
# GL/glext.h:9018
glCombinerOutputNV = _link_function('glCombinerOutputNV', None, [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean], 'NV_register_combiners')
# GL/glext.h:9019
glFinalCombinerInputNV = _link_function('glFinalCombinerInputNV', None, [GLenum, GLenum, GLenum, GLenum], 'NV_register_combiners')
# GL/glext.h:9020
glGetCombinerInputParameterfvNV = _link_function('glGetCombinerInputParameterfvNV', None, [GLenum, GLenum, GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:9021
glGetCombinerInputParameterivNV = _link_function('glGetCombinerInputParameterivNV', None, [GLenum, GLenum, GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:9022
glGetCombinerOutputParameterfvNV = _link_function('glGetCombinerOutputParameterfvNV', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:9023
glGetCombinerOutputParameterivNV = _link_function('glGetCombinerOutputParameterivNV', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
# GL/glext.h:9024
glGetFinalCombinerInputParameterfvNV = _link_function('glGetFinalCombinerInputParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners')
# GL/glext.h:9025
glGetFinalCombinerInputParameterivNV = _link_function('glGetFinalCombinerInputParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_register_combiners')
PFNGLCOMBINERPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9027
PFNGLCOMBINERPARAMETERFNVPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:9028
PFNGLCOMBINERPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9029
PFNGLCOMBINERPARAMETERINVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9030
PFNGLCOMBINERINPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:9031
PFNGLCOMBINEROUTPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean) # GL/glext.h:9032
PFNGLFINALCOMBINERINPUTNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:9033
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9034
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9035
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9036
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9037
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9038
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9039
# NV_fog_distance (GL/glext.h:9042)
GL_NV_fog_distance = 1 # GL/glext.h:9043
# NV_texgen_emboss (GL/glext.h:9046)
GL_NV_texgen_emboss = 1 # GL/glext.h:9047
# NV_blend_square (GL/glext.h:9050)
GL_NV_blend_square = 1 # GL/glext.h:9051
# NV_texture_env_combine4 (GL/glext.h:9054)
GL_NV_texture_env_combine4 = 1 # GL/glext.h:9055
# MESA_resize_buffers (GL/glext.h:9058)
GL_MESA_resize_buffers = 1 # GL/glext.h:9059
# GL/glext.h:9061
glResizeBuffersMESA = _link_function('glResizeBuffersMESA', None, [], 'MESA_resize_buffers')
PFNGLRESIZEBUFFERSMESAPROC = CFUNCTYPE(None) # GL/glext.h:9063
# MESA_window_pos (GL/glext.h:9066)
GL_MESA_window_pos = 1 # GL/glext.h:9067
# GL/glext.h:9069
glWindowPos2dMESA = _link_function('glWindowPos2dMESA', None, [GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:9070
glWindowPos2dvMESA = _link_function('glWindowPos2dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:9071
glWindowPos2fMESA = _link_function('glWindowPos2fMESA', None, [GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:9072
glWindowPos2fvMESA = _link_function('glWindowPos2fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:9073
glWindowPos2iMESA = _link_function('glWindowPos2iMESA', None, [GLint, GLint], 'MESA_window_pos')
# GL/glext.h:9074
glWindowPos2ivMESA = _link_function('glWindowPos2ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:9075
glWindowPos2sMESA = _link_function('glWindowPos2sMESA', None, [GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:9076
glWindowPos2svMESA = _link_function('glWindowPos2svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
# GL/glext.h:9077
glWindowPos3dMESA = _link_function('glWindowPos3dMESA', None, [GLdouble, GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:9078
glWindowPos3dvMESA = _link_function('glWindowPos3dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:9079
glWindowPos3fMESA = _link_function('glWindowPos3fMESA', None, [GLfloat, GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:9080
glWindowPos3fvMESA = _link_function('glWindowPos3fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:9081
glWindowPos3iMESA = _link_function('glWindowPos3iMESA', None, [GLint, GLint, GLint], 'MESA_window_pos')
# GL/glext.h:9082
glWindowPos3ivMESA = _link_function('glWindowPos3ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:9083
glWindowPos3sMESA = _link_function('glWindowPos3sMESA', None, [GLshort, GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:9084
glWindowPos3svMESA = _link_function('glWindowPos3svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
# GL/glext.h:9085
glWindowPos4dMESA = _link_function('glWindowPos4dMESA', None, [GLdouble, GLdouble, GLdouble, GLdouble], 'MESA_window_pos')
# GL/glext.h:9086
glWindowPos4dvMESA = _link_function('glWindowPos4dvMESA', None, [POINTER(GLdouble)], 'MESA_window_pos')
# GL/glext.h:9087
glWindowPos4fMESA = _link_function('glWindowPos4fMESA', None, [GLfloat, GLfloat, GLfloat, GLfloat], 'MESA_window_pos')
# GL/glext.h:9088
glWindowPos4fvMESA = _link_function('glWindowPos4fvMESA', None, [POINTER(GLfloat)], 'MESA_window_pos')
# GL/glext.h:9089
glWindowPos4iMESA = _link_function('glWindowPos4iMESA', None, [GLint, GLint, GLint, GLint], 'MESA_window_pos')
# GL/glext.h:9090
glWindowPos4ivMESA = _link_function('glWindowPos4ivMESA', None, [POINTER(GLint)], 'MESA_window_pos')
# GL/glext.h:9091
glWindowPos4sMESA = _link_function('glWindowPos4sMESA', None, [GLshort, GLshort, GLshort, GLshort], 'MESA_window_pos')
# GL/glext.h:9092
glWindowPos4svMESA = _link_function('glWindowPos4svMESA', None, [POINTER(GLshort)], 'MESA_window_pos')
PFNGLWINDOWPOS2DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:9094
PFNGLWINDOWPOS2DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:9095
PFNGLWINDOWPOS2FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:9096
PFNGLWINDOWPOS2FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:9097
PFNGLWINDOWPOS2IMESAPROC = CFUNCTYPE(None, GLint, GLint) # GL/glext.h:9098
PFNGLWINDOWPOS2IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:9099
PFNGLWINDOWPOS2SMESAPROC = CFUNCTYPE(None, GLshort, GLshort) # GL/glext.h:9100
PFNGLWINDOWPOS2SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:9101
PFNGLWINDOWPOS3DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble) # GL/glext.h:9102
PFNGLWINDOWPOS3DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:9103
PFNGLWINDOWPOS3FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat) # GL/glext.h:9104
PFNGLWINDOWPOS3FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:9105
PFNGLWINDOWPOS3IMESAPROC = CFUNCTYPE(None, GLint, GLint, GLint) # GL/glext.h:9106
PFNGLWINDOWPOS3IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:9107
PFNGLWINDOWPOS3SMESAPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort) # GL/glext.h:9108
PFNGLWINDOWPOS3SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:9109
PFNGLWINDOWPOS4DMESAPROC = CFUNCTYPE(None, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:9110
PFNGLWINDOWPOS4DVMESAPROC = CFUNCTYPE(None, POINTER(GLdouble)) # GL/glext.h:9111
PFNGLWINDOWPOS4FMESAPROC = CFUNCTYPE(None, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:9112
PFNGLWINDOWPOS4FVMESAPROC = CFUNCTYPE(None, POINTER(GLfloat)) # GL/glext.h:9113
PFNGLWINDOWPOS4IMESAPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:9114
PFNGLWINDOWPOS4IVMESAPROC = CFUNCTYPE(None, POINTER(GLint)) # GL/glext.h:9115
PFNGLWINDOWPOS4SMESAPROC = CFUNCTYPE(None, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:9116
PFNGLWINDOWPOS4SVMESAPROC = CFUNCTYPE(None, POINTER(GLshort)) # GL/glext.h:9117
# IBM_cull_vertex (GL/glext.h:9120)
GL_IBM_cull_vertex = 1 # GL/glext.h:9121
# IBM_multimode_draw_arrays (GL/glext.h:9124)
GL_IBM_multimode_draw_arrays = 1 # GL/glext.h:9125
# GL/glext.h:9127
glMultiModeDrawArraysIBM = _link_function('glMultiModeDrawArraysIBM', None, [POINTER(GLenum), POINTER(GLint), POINTER(GLsizei), GLsizei, GLint], 'IBM_multimode_draw_arrays')
# GL/glext.h:9128
glMultiModeDrawElementsIBM = _link_function('glMultiModeDrawElementsIBM', None, [POINTER(GLenum), POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, GLint], 'IBM_multimode_draw_arrays')
PFNGLMULTIMODEDRAWARRAYSIBMPROC = CFUNCTYPE(None, POINTER(GLenum), POINTER(GLint), POINTER(GLsizei), GLsizei, GLint) # GL/glext.h:9130
PFNGLMULTIMODEDRAWELEMENTSIBMPROC = CFUNCTYPE(None, POINTER(GLenum), POINTER(GLsizei), GLenum, POINTER(POINTER(GLvoid)), GLsizei, GLint) # GL/glext.h:9131
# IBM_vertex_array_lists (GL/glext.h:9134)
GL_IBM_vertex_array_lists = 1 # GL/glext.h:9135
# GL/glext.h:9137
glColorPointerListIBM = _link_function('glColorPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9138
glSecondaryColorPointerListIBM = _link_function('glSecondaryColorPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9139
glEdgeFlagPointerListIBM = _link_function('glEdgeFlagPointerListIBM', None, [GLint, POINTER(POINTER(GLboolean)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9140
glFogCoordPointerListIBM = _link_function('glFogCoordPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9141
glIndexPointerListIBM = _link_function('glIndexPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9142
glNormalPointerListIBM = _link_function('glNormalPointerListIBM', None, [GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9143
glTexCoordPointerListIBM = _link_function('glTexCoordPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
# GL/glext.h:9144
glVertexPointerListIBM = _link_function('glVertexPointerListIBM', None, [GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint], 'IBM_vertex_array_lists')
PFNGLCOLORPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9146
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9147
PFNGLEDGEFLAGPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, POINTER(POINTER(GLboolean)), GLint) # GL/glext.h:9148
PFNGLFOGCOORDPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9149
PFNGLINDEXPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9150
PFNGLNORMALPOINTERLISTIBMPROC = CFUNCTYPE(None, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9151
PFNGLTEXCOORDPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9152
PFNGLVERTEXPOINTERLISTIBMPROC = CFUNCTYPE(None, GLint, GLenum, GLint, POINTER(POINTER(GLvoid)), GLint) # GL/glext.h:9153
# SGIX_subsample (GL/glext.h:9156)
GL_SGIX_subsample = 1 # GL/glext.h:9157
# SGIX_ycrcba (GL/glext.h:9160)
GL_SGIX_ycrcba = 1 # GL/glext.h:9161
# SGIX_ycrcb_subsample (GL/glext.h:9164)
GL_SGIX_ycrcb_subsample = 1 # GL/glext.h:9165
# SGIX_depth_pass_instrument (GL/glext.h:9168)
GL_SGIX_depth_pass_instrument = 1 # GL/glext.h:9169
# 3DFX_texture_compression_FXT1 (GL/glext.h:9172)
GL_3DFX_texture_compression_FXT1 = 1 # GL/glext.h:9173
# 3DFX_multisample (GL/glext.h:9176)
GL_3DFX_multisample = 1 # GL/glext.h:9177
# 3DFX_tbuffer (GL/glext.h:9180)
GL_3DFX_tbuffer = 1 # GL/glext.h:9181
# GL/glext.h:9183
glTbufferMask3DFX = _link_function('glTbufferMask3DFX', None, [GLuint], '3DFX_tbuffer')
PFNGLTBUFFERMASK3DFXPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9185
# EXT_multisample (GL/glext.h:9188)
GL_EXT_multisample = 1 # GL/glext.h:9189
# GL/glext.h:9191
glSampleMaskEXT = _link_function('glSampleMaskEXT', None, [GLclampf, GLboolean], 'EXT_multisample')
# GL/glext.h:9192
glSamplePatternEXT = _link_function('glSamplePatternEXT', None, [GLenum], 'EXT_multisample')
PFNGLSAMPLEMASKEXTPROC = CFUNCTYPE(None, GLclampf, GLboolean) # GL/glext.h:9194
PFNGLSAMPLEPATTERNEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:9195
# SGIX_vertex_preclip (GL/glext.h:9198)
GL_SGIX_vertex_preclip = 1 # GL/glext.h:9199
# SGIX_convolution_accuracy (GL/glext.h:9202)
GL_SGIX_convolution_accuracy = 1 # GL/glext.h:9203
# SGIX_resample (GL/glext.h:9206)
GL_SGIX_resample = 1 # GL/glext.h:9207
# SGIS_point_line_texgen (GL/glext.h:9210)
GL_SGIS_point_line_texgen = 1 # GL/glext.h:9211
# SGIS_texture_color_mask (GL/glext.h:9214)
GL_SGIS_texture_color_mask = 1 # GL/glext.h:9215
# GL/glext.h:9217
glTextureColorMaskSGIS = _link_function('glTextureColorMaskSGIS', None, [GLboolean, GLboolean, GLboolean, GLboolean], 'SGIS_texture_color_mask')
PFNGLTEXTURECOLORMASKSGISPROC = CFUNCTYPE(None, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:9219
# SGIX_igloo_interface (GL/glext.h:9222)
GL_SGIX_igloo_interface = 1 # GL/glext.h:9223
# GL/glext.h:9225
glIglooInterfaceSGIX = _link_function('glIglooInterfaceSGIX', None, [GLenum, POINTER(GLvoid)], 'SGIX_igloo_interface')
PFNGLIGLOOINTERFACESGIXPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:9227
# EXT_texture_env_dot3 (GL/glext.h:9230)
GL_EXT_texture_env_dot3 = 1 # GL/glext.h:9231
# ATI_texture_mirror_once (GL/glext.h:9234)
GL_ATI_texture_mirror_once = 1 # GL/glext.h:9235
# NV_fence (GL/glext.h:9238)
GL_NV_fence = 1 # GL/glext.h:9239
# GL/glext.h:9241
glDeleteFencesNV = _link_function('glDeleteFencesNV', None, [GLsizei, POINTER(GLuint)], 'NV_fence')
# GL/glext.h:9242
glGenFencesNV = _link_function('glGenFencesNV', None, [GLsizei, POINTER(GLuint)], 'NV_fence')
# GL/glext.h:9243
glIsFenceNV = _link_function('glIsFenceNV', GLboolean, [GLuint], 'NV_fence')
# GL/glext.h:9244
glTestFenceNV = _link_function('glTestFenceNV', GLboolean, [GLuint], 'NV_fence')
# GL/glext.h:9245
glGetFenceivNV = _link_function('glGetFenceivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_fence')
# GL/glext.h:9246
glFinishFenceNV = _link_function('glFinishFenceNV', None, [GLuint], 'NV_fence')
# GL/glext.h:9247
glSetFenceNV = _link_function('glSetFenceNV', None, [GLuint, GLenum], 'NV_fence')
PFNGLDELETEFENCESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9249
PFNGLGENFENCESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9250
PFNGLISFENCENVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9251
PFNGLTESTFENCENVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9252
PFNGLGETFENCEIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9253
PFNGLFINISHFENCENVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9254
PFNGLSETFENCENVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:9255
# NV_evaluators (GL/glext.h:9258)
GL_NV_evaluators = 1 # GL/glext.h:9259
# GL/glext.h:9261
glMapControlPointsNV = _link_function('glMapControlPointsNV', None, [GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, POINTER(GLvoid)], 'NV_evaluators')
# GL/glext.h:9262
glMapParameterivNV = _link_function('glMapParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:9263
glMapParameterfvNV = _link_function('glMapParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:9264
glGetMapControlPointsNV = _link_function('glGetMapControlPointsNV', None, [GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, POINTER(GLvoid)], 'NV_evaluators')
# GL/glext.h:9265
glGetMapParameterivNV = _link_function('glGetMapParameterivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:9266
glGetMapParameterfvNV = _link_function('glGetMapParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:9267
glGetMapAttribParameterivNV = _link_function('glGetMapAttribParameterivNV', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'NV_evaluators')
# GL/glext.h:9268
glGetMapAttribParameterfvNV = _link_function('glGetMapAttribParameterfvNV', None, [GLenum, GLuint, GLenum, POINTER(GLfloat)], 'NV_evaluators')
# GL/glext.h:9269
glEvalMapsNV = _link_function('glEvalMapsNV', None, [GLenum, GLenum], 'NV_evaluators')
PFNGLMAPCONTROLPOINTSNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, POINTER(GLvoid)) # GL/glext.h:9271
PFNGLMAPPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9272
PFNGLMAPPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9273
PFNGLGETMAPCONTROLPOINTSNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, POINTER(GLvoid)) # GL/glext.h:9274
PFNGLGETMAPPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9275
PFNGLGETMAPPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9276
PFNGLGETMAPATTRIBPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9277
PFNGLGETMAPATTRIBPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9278
PFNGLEVALMAPSNVPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:9279
# NV_packed_depth_stencil (GL/glext.h:9282)
GL_NV_packed_depth_stencil = 1 # GL/glext.h:9283
# NV_register_combiners2 (GL/glext.h:9286)
GL_NV_register_combiners2 = 1 # GL/glext.h:9287
# GL/glext.h:9289
glCombinerStageParameterfvNV = _link_function('glCombinerStageParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners2')
# GL/glext.h:9290
glGetCombinerStageParameterfvNV = _link_function('glGetCombinerStageParameterfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_register_combiners2')
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9292
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9293
# NV_texture_compression_vtc (GL/glext.h:9296)
GL_NV_texture_compression_vtc = 1 # GL/glext.h:9297
# NV_texture_rectangle (GL/glext.h:9300)
GL_NV_texture_rectangle = 1 # GL/glext.h:9301
# NV_texture_shader (GL/glext.h:9304)
GL_NV_texture_shader = 1 # GL/glext.h:9305
# NV_texture_shader2 (GL/glext.h:9308)
GL_NV_texture_shader2 = 1 # GL/glext.h:9309
# NV_vertex_array_range2 (GL/glext.h:9312)
GL_NV_vertex_array_range2 = 1 # GL/glext.h:9313
# NV_vertex_program (GL/glext.h:9316)
GL_NV_vertex_program = 1 # GL/glext.h:9317
# GL/glext.h:9319
glAreProgramsResidentNV = _link_function('glAreProgramsResidentNV', GLboolean, [GLsizei, POINTER(GLuint), POINTER(GLboolean)], 'NV_vertex_program')
# GL/glext.h:9320
glBindProgramNV = _link_function('glBindProgramNV', None, [GLenum, GLuint], 'NV_vertex_program')
# GL/glext.h:9321
glDeleteProgramsNV = _link_function('glDeleteProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:9322
glExecuteProgramNV = _link_function('glExecuteProgramNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9323
glGenProgramsNV = _link_function('glGenProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:9324
glGetProgramParameterdvNV = _link_function('glGetProgramParameterdvNV', None, [GLenum, GLuint, GLenum, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9325
glGetProgramParameterfvNV = _link_function('glGetProgramParameterfvNV', None, [GLenum, GLuint, GLenum, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9326
glGetProgramivNV = _link_function('glGetProgramivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:9327
glGetProgramStringNV = _link_function('glGetProgramStringNV', None, [GLuint, GLenum, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:9328
glGetTrackMatrixivNV = _link_function('glGetTrackMatrixivNV', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:9329
glGetVertexAttribdvNV = _link_function('glGetVertexAttribdvNV', None, [GLuint, GLenum, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9330
glGetVertexAttribfvNV = _link_function('glGetVertexAttribfvNV', None, [GLuint, GLenum, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9331
glGetVertexAttribivNV = _link_function('glGetVertexAttribivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program')
# GL/glext.h:9332
glGetVertexAttribPointervNV = _link_function('glGetVertexAttribPointervNV', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'NV_vertex_program')
# GL/glext.h:9333
glIsProgramNV = _link_function('glIsProgramNV', GLboolean, [GLuint], 'NV_vertex_program')
# GL/glext.h:9334
glLoadProgramNV = _link_function('glLoadProgramNV', None, [GLenum, GLuint, GLsizei, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:9335
glProgramParameter4dNV = _link_function('glProgramParameter4dNV', None, [GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:9336
glProgramParameter4dvNV = _link_function('glProgramParameter4dvNV', None, [GLenum, GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9337
glProgramParameter4fNV = _link_function('glProgramParameter4fNV', None, [GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:9338
glProgramParameter4fvNV = _link_function('glProgramParameter4fvNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9339
glProgramParameters4dvNV = _link_function('glProgramParameters4dvNV', None, [GLenum, GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9340
glProgramParameters4fvNV = _link_function('glProgramParameters4fvNV', None, [GLenum, GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9341
glRequestResidentProgramsNV = _link_function('glRequestResidentProgramsNV', None, [GLsizei, POINTER(GLuint)], 'NV_vertex_program')
# GL/glext.h:9342
glTrackMatrixNV = _link_function('glTrackMatrixNV', None, [GLenum, GLuint, GLenum, GLenum], 'NV_vertex_program')
# GL/glext.h:9343
glVertexAttribPointerNV = _link_function('glVertexAttribPointerNV', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'NV_vertex_program')
# GL/glext.h:9344
glVertexAttrib1dNV = _link_function('glVertexAttrib1dNV', None, [GLuint, GLdouble], 'NV_vertex_program')
# GL/glext.h:9345
glVertexAttrib1dvNV = _link_function('glVertexAttrib1dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9346
glVertexAttrib1fNV = _link_function('glVertexAttrib1fNV', None, [GLuint, GLfloat], 'NV_vertex_program')
# GL/glext.h:9347
glVertexAttrib1fvNV = _link_function('glVertexAttrib1fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9348
glVertexAttrib1sNV = _link_function('glVertexAttrib1sNV', None, [GLuint, GLshort], 'NV_vertex_program')
# GL/glext.h:9349
glVertexAttrib1svNV = _link_function('glVertexAttrib1svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9350
glVertexAttrib2dNV = _link_function('glVertexAttrib2dNV', None, [GLuint, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:9351
glVertexAttrib2dvNV = _link_function('glVertexAttrib2dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9352
glVertexAttrib2fNV = _link_function('glVertexAttrib2fNV', None, [GLuint, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:9353
glVertexAttrib2fvNV = _link_function('glVertexAttrib2fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9354
glVertexAttrib2sNV = _link_function('glVertexAttrib2sNV', None, [GLuint, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:9355
glVertexAttrib2svNV = _link_function('glVertexAttrib2svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9356
glVertexAttrib3dNV = _link_function('glVertexAttrib3dNV', None, [GLuint, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:9357
glVertexAttrib3dvNV = _link_function('glVertexAttrib3dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9358
glVertexAttrib3fNV = _link_function('glVertexAttrib3fNV', None, [GLuint, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:9359
glVertexAttrib3fvNV = _link_function('glVertexAttrib3fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9360
glVertexAttrib3sNV = _link_function('glVertexAttrib3sNV', None, [GLuint, GLshort, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:9361
glVertexAttrib3svNV = _link_function('glVertexAttrib3svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9362
glVertexAttrib4dNV = _link_function('glVertexAttrib4dNV', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'NV_vertex_program')
# GL/glext.h:9363
glVertexAttrib4dvNV = _link_function('glVertexAttrib4dvNV', None, [GLuint, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9364
glVertexAttrib4fNV = _link_function('glVertexAttrib4fNV', None, [GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'NV_vertex_program')
# GL/glext.h:9365
glVertexAttrib4fvNV = _link_function('glVertexAttrib4fvNV', None, [GLuint, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9366
glVertexAttrib4sNV = _link_function('glVertexAttrib4sNV', None, [GLuint, GLshort, GLshort, GLshort, GLshort], 'NV_vertex_program')
# GL/glext.h:9367
glVertexAttrib4svNV = _link_function('glVertexAttrib4svNV', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9368
glVertexAttrib4ubNV = _link_function('glVertexAttrib4ubNV', None, [GLuint, GLubyte, GLubyte, GLubyte, GLubyte], 'NV_vertex_program')
# GL/glext.h:9369
glVertexAttrib4ubvNV = _link_function('glVertexAttrib4ubvNV', None, [GLuint, POINTER(GLubyte)], 'NV_vertex_program')
# GL/glext.h:9370
glVertexAttribs1dvNV = _link_function('glVertexAttribs1dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9371
glVertexAttribs1fvNV = _link_function('glVertexAttribs1fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9372
glVertexAttribs1svNV = _link_function('glVertexAttribs1svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9373
glVertexAttribs2dvNV = _link_function('glVertexAttribs2dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9374
glVertexAttribs2fvNV = _link_function('glVertexAttribs2fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9375
glVertexAttribs2svNV = _link_function('glVertexAttribs2svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9376
glVertexAttribs3dvNV = _link_function('glVertexAttribs3dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9377
glVertexAttribs3fvNV = _link_function('glVertexAttribs3fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9378
glVertexAttribs3svNV = _link_function('glVertexAttribs3svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9379
glVertexAttribs4dvNV = _link_function('glVertexAttribs4dvNV', None, [GLuint, GLsizei, POINTER(GLdouble)], 'NV_vertex_program')
# GL/glext.h:9380
glVertexAttribs4fvNV = _link_function('glVertexAttribs4fvNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_vertex_program')
# GL/glext.h:9381
glVertexAttribs4svNV = _link_function('glVertexAttribs4svNV', None, [GLuint, GLsizei, POINTER(GLshort)], 'NV_vertex_program')
# GL/glext.h:9382
glVertexAttribs4ubvNV = _link_function('glVertexAttribs4ubvNV', None, [GLuint, GLsizei, POINTER(GLubyte)], 'NV_vertex_program')
PFNGLAREPROGRAMSRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLsizei, POINTER(GLuint), POINTER(GLboolean)) # GL/glext.h:9384
PFNGLBINDPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:9385
PFNGLDELETEPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9386
PFNGLEXECUTEPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:9387
PFNGLGENPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9388
PFNGLGETPROGRAMPARAMETERDVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:9389
PFNGLGETPROGRAMPARAMETERFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9390
PFNGLGETPROGRAMIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9391
PFNGLGETPROGRAMSTRINGNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLubyte)) # GL/glext.h:9392
PFNGLGETTRACKMATRIXIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9393
PFNGLGETVERTEXATTRIBDVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:9394
PFNGLGETVERTEXATTRIBFVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9395
PFNGLGETVERTEXATTRIBIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9396
PFNGLGETVERTEXATTRIBPOINTERVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:9397
PFNGLISPROGRAMNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9398
PFNGLLOADPROGRAMNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLubyte)) # GL/glext.h:9399
PFNGLPROGRAMPARAMETER4DNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:9400
PFNGLPROGRAMPARAMETER4DVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:9401
PFNGLPROGRAMPARAMETER4FNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:9402
PFNGLPROGRAMPARAMETER4FVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:9403
PFNGLPROGRAMPARAMETERS4DVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:9404
PFNGLPROGRAMPARAMETERS4FVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:9405
PFNGLREQUESTRESIDENTPROGRAMSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9406
PFNGLTRACKMATRIXNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, GLenum) # GL/glext.h:9407
PFNGLVERTEXATTRIBPOINTERNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:9408
PFNGLVERTEXATTRIB1DNVPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:9409
PFNGLVERTEXATTRIB1DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:9410
PFNGLVERTEXATTRIB1FNVPROC = CFUNCTYPE(None, GLuint, GLfloat) # GL/glext.h:9411
PFNGLVERTEXATTRIB1FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9412
PFNGLVERTEXATTRIB1SNVPROC = CFUNCTYPE(None, GLuint, GLshort) # GL/glext.h:9413
PFNGLVERTEXATTRIB1SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:9414
PFNGLVERTEXATTRIB2DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:9415
PFNGLVERTEXATTRIB2DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:9416
PFNGLVERTEXATTRIB2FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat) # GL/glext.h:9417
PFNGLVERTEXATTRIB2FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9418
PFNGLVERTEXATTRIB2SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort) # GL/glext.h:9419
PFNGLVERTEXATTRIB2SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:9420
PFNGLVERTEXATTRIB3DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:9421
PFNGLVERTEXATTRIB3DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:9422
PFNGLVERTEXATTRIB3FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat) # GL/glext.h:9423
PFNGLVERTEXATTRIB3FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9424
PFNGLVERTEXATTRIB3SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort) # GL/glext.h:9425
PFNGLVERTEXATTRIB3SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:9426
PFNGLVERTEXATTRIB4DNVPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:9427
PFNGLVERTEXATTRIB4DVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:9428
PFNGLVERTEXATTRIB4FNVPROC = CFUNCTYPE(None, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:9429
PFNGLVERTEXATTRIB4FVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9430
PFNGLVERTEXATTRIB4SNVPROC = CFUNCTYPE(None, GLuint, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:9431
PFNGLVERTEXATTRIB4SVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:9432
PFNGLVERTEXATTRIB4UBNVPROC = CFUNCTYPE(None, GLuint, GLubyte, GLubyte, GLubyte, GLubyte) # GL/glext.h:9433
PFNGLVERTEXATTRIB4UBVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:9434
PFNGLVERTEXATTRIBS1DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:9435
PFNGLVERTEXATTRIBS1FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:9436
PFNGLVERTEXATTRIBS1SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:9437
PFNGLVERTEXATTRIBS2DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:9438
PFNGLVERTEXATTRIBS2FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:9439
PFNGLVERTEXATTRIBS2SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:9440
PFNGLVERTEXATTRIBS3DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:9441
PFNGLVERTEXATTRIBS3FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:9442
PFNGLVERTEXATTRIBS3SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:9443
PFNGLVERTEXATTRIBS4DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLdouble)) # GL/glext.h:9444
PFNGLVERTEXATTRIBS4FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:9445
PFNGLVERTEXATTRIBS4SVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLshort)) # GL/glext.h:9446
PFNGLVERTEXATTRIBS4UBVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte)) # GL/glext.h:9447
# SGIX_texture_coordinate_clamp (GL/glext.h:9450)
GL_SGIX_texture_coordinate_clamp = 1 # GL/glext.h:9451
# SGIX_scalebias_hint (GL/glext.h:9454)
GL_SGIX_scalebias_hint = 1 # GL/glext.h:9455
# OML_interlace (GL/glext.h:9458)
GL_OML_interlace = 1 # GL/glext.h:9459
# OML_subsample (GL/glext.h:9462)
GL_OML_subsample = 1 # GL/glext.h:9463
# OML_resample (GL/glext.h:9466)
GL_OML_resample = 1 # GL/glext.h:9467
# NV_copy_depth_to_color (GL/glext.h:9470)
GL_NV_copy_depth_to_color = 1 # GL/glext.h:9471
# ATI_envmap_bumpmap (GL/glext.h:9474)
GL_ATI_envmap_bumpmap = 1 # GL/glext.h:9475
# GL/glext.h:9477
glTexBumpParameterivATI = _link_function('glTexBumpParameterivATI', None, [GLenum, POINTER(GLint)], 'ATI_envmap_bumpmap')
# GL/glext.h:9478
glTexBumpParameterfvATI = _link_function('glTexBumpParameterfvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_envmap_bumpmap')
# GL/glext.h:9479
glGetTexBumpParameterivATI = _link_function('glGetTexBumpParameterivATI', None, [GLenum, POINTER(GLint)], 'ATI_envmap_bumpmap')
# GL/glext.h:9480
glGetTexBumpParameterfvATI = _link_function('glGetTexBumpParameterfvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_envmap_bumpmap')
PFNGLTEXBUMPPARAMETERIVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9482
PFNGLTEXBUMPPARAMETERFVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9483
PFNGLGETTEXBUMPPARAMETERIVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9484
PFNGLGETTEXBUMPPARAMETERFVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9485
# ATI_fragment_shader (GL/glext.h:9488)
GL_ATI_fragment_shader = 1 # GL/glext.h:9489
# GL/glext.h:9491
glGenFragmentShadersATI = _link_function('glGenFragmentShadersATI', GLuint, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:9492
glBindFragmentShaderATI = _link_function('glBindFragmentShaderATI', None, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:9493
glDeleteFragmentShaderATI = _link_function('glDeleteFragmentShaderATI', None, [GLuint], 'ATI_fragment_shader')
# GL/glext.h:9494
glBeginFragmentShaderATI = _link_function('glBeginFragmentShaderATI', None, [], 'ATI_fragment_shader')
# GL/glext.h:9495
glEndFragmentShaderATI = _link_function('glEndFragmentShaderATI', None, [], 'ATI_fragment_shader')
# GL/glext.h:9496
glPassTexCoordATI = _link_function('glPassTexCoordATI', None, [GLuint, GLuint, GLenum], 'ATI_fragment_shader')
# GL/glext.h:9497
glSampleMapATI = _link_function('glSampleMapATI', None, [GLuint, GLuint, GLenum], 'ATI_fragment_shader')
# GL/glext.h:9498
glColorFragmentOp1ATI = _link_function('glColorFragmentOp1ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9499
glColorFragmentOp2ATI = _link_function('glColorFragmentOp2ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9500
glColorFragmentOp3ATI = _link_function('glColorFragmentOp3ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9501
glAlphaFragmentOp1ATI = _link_function('glAlphaFragmentOp1ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9502
glAlphaFragmentOp2ATI = _link_function('glAlphaFragmentOp2ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9503
glAlphaFragmentOp3ATI = _link_function('glAlphaFragmentOp3ATI', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint], 'ATI_fragment_shader')
# GL/glext.h:9504
glSetFragmentShaderConstantATI = _link_function('glSetFragmentShaderConstantATI', None, [GLuint, POINTER(GLfloat)], 'ATI_fragment_shader')
PFNGLGENFRAGMENTSHADERSATIPROC = CFUNCTYPE(GLuint, GLuint) # GL/glext.h:9506
PFNGLBINDFRAGMENTSHADERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9507
PFNGLDELETEFRAGMENTSHADERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9508
PFNGLBEGINFRAGMENTSHADERATIPROC = CFUNCTYPE(None) # GL/glext.h:9509
PFNGLENDFRAGMENTSHADERATIPROC = CFUNCTYPE(None) # GL/glext.h:9510
PFNGLPASSTEXCOORDATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum) # GL/glext.h:9511
PFNGLSAMPLEMAPATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum) # GL/glext.h:9512
PFNGLCOLORFRAGMENTOP1ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9513
PFNGLCOLORFRAGMENTOP2ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9514
PFNGLCOLORFRAGMENTOP3ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9515
PFNGLALPHAFRAGMENTOP1ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9516
PFNGLALPHAFRAGMENTOP2ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9517
PFNGLALPHAFRAGMENTOP3ATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9518
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9519
# ATI_pn_triangles (GL/glext.h:9522)
GL_ATI_pn_triangles = 1 # GL/glext.h:9523
# GL/glext.h:9525
glPNTrianglesiATI = _link_function('glPNTrianglesiATI', None, [GLenum, GLint], 'ATI_pn_triangles')
# GL/glext.h:9526
glPNTrianglesfATI = _link_function('glPNTrianglesfATI', None, [GLenum, GLfloat], 'ATI_pn_triangles')
PFNGLPNTRIANGLESIATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9528
PFNGLPNTRIANGLESFATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:9529
# ATI_vertex_array_object (GL/glext.h:9532)
GL_ATI_vertex_array_object = 1 # GL/glext.h:9533
# GL/glext.h:9535
glNewObjectBufferATI = _link_function('glNewObjectBufferATI', GLuint, [GLsizei, POINTER(GLvoid), GLenum], 'ATI_vertex_array_object')
# GL/glext.h:9536
glIsObjectBufferATI = _link_function('glIsObjectBufferATI', GLboolean, [GLuint], 'ATI_vertex_array_object')
# GL/glext.h:9537
glUpdateObjectBufferATI = _link_function('glUpdateObjectBufferATI', None, [GLuint, GLuint, GLsizei, POINTER(GLvoid), GLenum], 'ATI_vertex_array_object')
# GL/glext.h:9538
glGetObjectBufferfvATI = _link_function('glGetObjectBufferfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:9539
glGetObjectBufferivATI = _link_function('glGetObjectBufferivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
# GL/glext.h:9540
glFreeObjectBufferATI = _link_function('glFreeObjectBufferATI', None, [GLuint], 'ATI_vertex_array_object')
# GL/glext.h:9541
glArrayObjectATI = _link_function('glArrayObjectATI', None, [GLenum, GLint, GLenum, GLsizei, GLuint, GLuint], 'ATI_vertex_array_object')
# GL/glext.h:9542
glGetArrayObjectfvATI = _link_function('glGetArrayObjectfvATI', None, [GLenum, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:9543
glGetArrayObjectivATI = _link_function('glGetArrayObjectivATI', None, [GLenum, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
# GL/glext.h:9544
glVariantArrayObjectATI = _link_function('glVariantArrayObjectATI', None, [GLuint, GLenum, GLsizei, GLuint, GLuint], 'ATI_vertex_array_object')
# GL/glext.h:9545
glGetVariantArrayObjectfvATI = _link_function('glGetVariantArrayObjectfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_array_object')
# GL/glext.h:9546
glGetVariantArrayObjectivATI = _link_function('glGetVariantArrayObjectivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_array_object')
PFNGLNEWOBJECTBUFFERATIPROC = CFUNCTYPE(GLuint, GLsizei, POINTER(GLvoid), GLenum) # GL/glext.h:9548
PFNGLISOBJECTBUFFERATIPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9549
PFNGLUPDATEOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLvoid), GLenum) # GL/glext.h:9550
PFNGLGETOBJECTBUFFERFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9551
PFNGLGETOBJECTBUFFERIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9552
PFNGLFREEOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9553
PFNGLARRAYOBJECTATIPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, GLuint, GLuint) # GL/glext.h:9554
PFNGLGETARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:9555
PFNGLGETARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:9556
PFNGLVARIANTARRAYOBJECTATIPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLuint, GLuint) # GL/glext.h:9557
PFNGLGETVARIANTARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9558
PFNGLGETVARIANTARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9559
# EXT_vertex_shader (GL/glext.h:9562)
GL_EXT_vertex_shader = 1 # GL/glext.h:9563
# GL/glext.h:9565
glBeginVertexShaderEXT = _link_function('glBeginVertexShaderEXT', None, [], 'EXT_vertex_shader')
# GL/glext.h:9566
glEndVertexShaderEXT = _link_function('glEndVertexShaderEXT', None, [], 'EXT_vertex_shader')
# GL/glext.h:9567
glBindVertexShaderEXT = _link_function('glBindVertexShaderEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:9568
glGenVertexShadersEXT = _link_function('glGenVertexShadersEXT', GLuint, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:9569
glDeleteVertexShaderEXT = _link_function('glDeleteVertexShaderEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:9570
glShaderOp1EXT = _link_function('glShaderOp1EXT', None, [GLenum, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9571
glShaderOp2EXT = _link_function('glShaderOp2EXT', None, [GLenum, GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9572
glShaderOp3EXT = _link_function('glShaderOp3EXT', None, [GLenum, GLuint, GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9573
glSwizzleEXT = _link_function('glSwizzleEXT', None, [GLuint, GLuint, GLenum, GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9574
glWriteMaskEXT = _link_function('glWriteMaskEXT', None, [GLuint, GLuint, GLenum, GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9575
glInsertComponentEXT = _link_function('glInsertComponentEXT', None, [GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9576
glExtractComponentEXT = _link_function('glExtractComponentEXT', None, [GLuint, GLuint, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9577
glGenSymbolsEXT = _link_function('glGenSymbolsEXT', GLuint, [GLenum, GLenum, GLenum, GLuint], 'EXT_vertex_shader')
# GL/glext.h:9578
glSetInvariantEXT = _link_function('glSetInvariantEXT', None, [GLuint, GLenum, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:9579
glSetLocalConstantEXT = _link_function('glSetLocalConstantEXT', None, [GLuint, GLenum, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:9580
glVariantbvEXT = _link_function('glVariantbvEXT', None, [GLuint, POINTER(GLbyte)], 'EXT_vertex_shader')
# GL/glext.h:9581
glVariantsvEXT = _link_function('glVariantsvEXT', None, [GLuint, POINTER(GLshort)], 'EXT_vertex_shader')
# GL/glext.h:9582
glVariantivEXT = _link_function('glVariantivEXT', None, [GLuint, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:9583
glVariantfvEXT = _link_function('glVariantfvEXT', None, [GLuint, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:9584
glVariantdvEXT = _link_function('glVariantdvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_shader')
# GL/glext.h:9585
glVariantubvEXT = _link_function('glVariantubvEXT', None, [GLuint, POINTER(GLubyte)], 'EXT_vertex_shader')
# GL/glext.h:9586
glVariantusvEXT = _link_function('glVariantusvEXT', None, [GLuint, POINTER(GLushort)], 'EXT_vertex_shader')
# GL/glext.h:9587
glVariantuivEXT = _link_function('glVariantuivEXT', None, [GLuint, POINTER(GLuint)], 'EXT_vertex_shader')
# GL/glext.h:9588
glVariantPointerEXT = _link_function('glVariantPointerEXT', None, [GLuint, GLenum, GLuint, POINTER(GLvoid)], 'EXT_vertex_shader')
# GL/glext.h:9589
glEnableVariantClientStateEXT = _link_function('glEnableVariantClientStateEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:9590
glDisableVariantClientStateEXT = _link_function('glDisableVariantClientStateEXT', None, [GLuint], 'EXT_vertex_shader')
# GL/glext.h:9591
glBindLightParameterEXT = _link_function('glBindLightParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9592
glBindMaterialParameterEXT = _link_function('glBindMaterialParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9593
glBindTexGenParameterEXT = _link_function('glBindTexGenParameterEXT', GLuint, [GLenum, GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9594
glBindTextureUnitParameterEXT = _link_function('glBindTextureUnitParameterEXT', GLuint, [GLenum, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9595
glBindParameterEXT = _link_function('glBindParameterEXT', GLuint, [GLenum], 'EXT_vertex_shader')
# GL/glext.h:9596
glIsVariantEnabledEXT = _link_function('glIsVariantEnabledEXT', GLboolean, [GLuint, GLenum], 'EXT_vertex_shader')
# GL/glext.h:9597
glGetVariantBooleanvEXT = _link_function('glGetVariantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:9598
glGetVariantIntegervEXT = _link_function('glGetVariantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:9599
glGetVariantFloatvEXT = _link_function('glGetVariantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:9600
glGetVariantPointervEXT = _link_function('glGetVariantPointervEXT', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'EXT_vertex_shader')
# GL/glext.h:9601
glGetInvariantBooleanvEXT = _link_function('glGetInvariantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:9602
glGetInvariantIntegervEXT = _link_function('glGetInvariantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:9603
glGetInvariantFloatvEXT = _link_function('glGetInvariantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
# GL/glext.h:9604
glGetLocalConstantBooleanvEXT = _link_function('glGetLocalConstantBooleanvEXT', None, [GLuint, GLenum, POINTER(GLboolean)], 'EXT_vertex_shader')
# GL/glext.h:9605
glGetLocalConstantIntegervEXT = _link_function('glGetLocalConstantIntegervEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_vertex_shader')
# GL/glext.h:9606
glGetLocalConstantFloatvEXT = _link_function('glGetLocalConstantFloatvEXT', None, [GLuint, GLenum, POINTER(GLfloat)], 'EXT_vertex_shader')
PFNGLBEGINVERTEXSHADEREXTPROC = CFUNCTYPE(None) # GL/glext.h:9608
PFNGLENDVERTEXSHADEREXTPROC = CFUNCTYPE(None) # GL/glext.h:9609
PFNGLBINDVERTEXSHADEREXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9610
PFNGLGENVERTEXSHADERSEXTPROC = CFUNCTYPE(GLuint, GLuint) # GL/glext.h:9611
PFNGLDELETEVERTEXSHADEREXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9612
PFNGLSHADEROP1EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:9613
PFNGLSHADEROP2EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint) # GL/glext.h:9614
PFNGLSHADEROP3EXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:9615
PFNGLSWIZZLEEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:9616
PFNGLWRITEMASKEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:9617
PFNGLINSERTCOMPONENTEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:9618
PFNGLEXTRACTCOMPONENTEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:9619
PFNGLGENSYMBOLSEXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:9620
PFNGLSETINVARIANTEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid)) # GL/glext.h:9621
PFNGLSETLOCALCONSTANTEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid)) # GL/glext.h:9622
PFNGLVARIANTBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:9623
PFNGLVARIANTSVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:9624
PFNGLVARIANTIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:9625
PFNGLVARIANTFVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:9626
PFNGLVARIANTDVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:9627
PFNGLVARIANTUBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:9628
PFNGLVARIANTUSVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:9629
PFNGLVARIANTUIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:9630
PFNGLVARIANTPOINTEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLvoid)) # GL/glext.h:9631
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9632
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9633
PFNGLBINDLIGHTPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:9634
PFNGLBINDMATERIALPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:9635
PFNGLBINDTEXGENPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum, GLenum) # GL/glext.h:9636
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum, GLenum) # GL/glext.h:9637
PFNGLBINDPARAMETEREXTPROC = CFUNCTYPE(GLuint, GLenum) # GL/glext.h:9638
PFNGLISVARIANTENABLEDEXTPROC = CFUNCTYPE(GLboolean, GLuint, GLenum) # GL/glext.h:9639
PFNGLGETVARIANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:9640
PFNGLGETVARIANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9641
PFNGLGETVARIANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9642
PFNGLGETVARIANTPOINTERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:9643
PFNGLGETINVARIANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:9644
PFNGLGETINVARIANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9645
PFNGLGETINVARIANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9646
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLboolean)) # GL/glext.h:9647
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9648
PFNGLGETLOCALCONSTANTFLOATVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:9649
# ATI_vertex_streams (GL/glext.h:9652)
GL_ATI_vertex_streams = 1 # GL/glext.h:9653
# GL/glext.h:9655
glVertexStream1sATI = _link_function('glVertexStream1sATI', None, [GLenum, GLshort], 'ATI_vertex_streams')
# GL/glext.h:9656
glVertexStream1svATI = _link_function('glVertexStream1svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:9657
glVertexStream1iATI = _link_function('glVertexStream1iATI', None, [GLenum, GLint], 'ATI_vertex_streams')
# GL/glext.h:9658
glVertexStream1ivATI = _link_function('glVertexStream1ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:9659
glVertexStream1fATI = _link_function('glVertexStream1fATI', None, [GLenum, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:9660
glVertexStream1fvATI = _link_function('glVertexStream1fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:9661
glVertexStream1dATI = _link_function('glVertexStream1dATI', None, [GLenum, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:9662
glVertexStream1dvATI = _link_function('glVertexStream1dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:9663
glVertexStream2sATI = _link_function('glVertexStream2sATI', None, [GLenum, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:9664
glVertexStream2svATI = _link_function('glVertexStream2svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:9665
glVertexStream2iATI = _link_function('glVertexStream2iATI', None, [GLenum, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:9666
glVertexStream2ivATI = _link_function('glVertexStream2ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:9667
glVertexStream2fATI = _link_function('glVertexStream2fATI', None, [GLenum, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:9668
glVertexStream2fvATI = _link_function('glVertexStream2fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:9669
glVertexStream2dATI = _link_function('glVertexStream2dATI', None, [GLenum, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:9670
glVertexStream2dvATI = _link_function('glVertexStream2dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:9671
glVertexStream3sATI = _link_function('glVertexStream3sATI', None, [GLenum, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:9672
glVertexStream3svATI = _link_function('glVertexStream3svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:9673
glVertexStream3iATI = _link_function('glVertexStream3iATI', None, [GLenum, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:9674
glVertexStream3ivATI = _link_function('glVertexStream3ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:9675
glVertexStream3fATI = _link_function('glVertexStream3fATI', None, [GLenum, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:9676
glVertexStream3fvATI = _link_function('glVertexStream3fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:9677
glVertexStream3dATI = _link_function('glVertexStream3dATI', None, [GLenum, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:9678
glVertexStream3dvATI = _link_function('glVertexStream3dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:9679
glVertexStream4sATI = _link_function('glVertexStream4sATI', None, [GLenum, GLshort, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:9680
glVertexStream4svATI = _link_function('glVertexStream4svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:9681
glVertexStream4iATI = _link_function('glVertexStream4iATI', None, [GLenum, GLint, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:9682
glVertexStream4ivATI = _link_function('glVertexStream4ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:9683
glVertexStream4fATI = _link_function('glVertexStream4fATI', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:9684
glVertexStream4fvATI = _link_function('glVertexStream4fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:9685
glVertexStream4dATI = _link_function('glVertexStream4dATI', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:9686
glVertexStream4dvATI = _link_function('glVertexStream4dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:9687
glNormalStream3bATI = _link_function('glNormalStream3bATI', None, [GLenum, GLbyte, GLbyte, GLbyte], 'ATI_vertex_streams')
# GL/glext.h:9688
glNormalStream3bvATI = _link_function('glNormalStream3bvATI', None, [GLenum, POINTER(GLbyte)], 'ATI_vertex_streams')
# GL/glext.h:9689
glNormalStream3sATI = _link_function('glNormalStream3sATI', None, [GLenum, GLshort, GLshort, GLshort], 'ATI_vertex_streams')
# GL/glext.h:9690
glNormalStream3svATI = _link_function('glNormalStream3svATI', None, [GLenum, POINTER(GLshort)], 'ATI_vertex_streams')
# GL/glext.h:9691
glNormalStream3iATI = _link_function('glNormalStream3iATI', None, [GLenum, GLint, GLint, GLint], 'ATI_vertex_streams')
# GL/glext.h:9692
glNormalStream3ivATI = _link_function('glNormalStream3ivATI', None, [GLenum, POINTER(GLint)], 'ATI_vertex_streams')
# GL/glext.h:9693
glNormalStream3fATI = _link_function('glNormalStream3fATI', None, [GLenum, GLfloat, GLfloat, GLfloat], 'ATI_vertex_streams')
# GL/glext.h:9694
glNormalStream3fvATI = _link_function('glNormalStream3fvATI', None, [GLenum, POINTER(GLfloat)], 'ATI_vertex_streams')
# GL/glext.h:9695
glNormalStream3dATI = _link_function('glNormalStream3dATI', None, [GLenum, GLdouble, GLdouble, GLdouble], 'ATI_vertex_streams')
# GL/glext.h:9696
glNormalStream3dvATI = _link_function('glNormalStream3dvATI', None, [GLenum, POINTER(GLdouble)], 'ATI_vertex_streams')
# GL/glext.h:9697
glClientActiveVertexStreamATI = _link_function('glClientActiveVertexStreamATI', None, [GLenum], 'ATI_vertex_streams')
# GL/glext.h:9698
glVertexBlendEnviATI = _link_function('glVertexBlendEnviATI', None, [GLenum, GLint], 'ATI_vertex_streams')
# GL/glext.h:9699
glVertexBlendEnvfATI = _link_function('glVertexBlendEnvfATI', None, [GLenum, GLfloat], 'ATI_vertex_streams')
PFNGLVERTEXSTREAM1SATIPROC = CFUNCTYPE(None, GLenum, GLshort) # GL/glext.h:9701
PFNGLVERTEXSTREAM1SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:9702
PFNGLVERTEXSTREAM1IATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9703
PFNGLVERTEXSTREAM1IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9704
PFNGLVERTEXSTREAM1FATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:9705
PFNGLVERTEXSTREAM1FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9706
PFNGLVERTEXSTREAM1DATIPROC = CFUNCTYPE(None, GLenum, GLdouble) # GL/glext.h:9707
PFNGLVERTEXSTREAM1DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:9708
PFNGLVERTEXSTREAM2SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort) # GL/glext.h:9709
PFNGLVERTEXSTREAM2SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:9710
PFNGLVERTEXSTREAM2IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint) # GL/glext.h:9711
PFNGLVERTEXSTREAM2IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9712
PFNGLVERTEXSTREAM2FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat) # GL/glext.h:9713
PFNGLVERTEXSTREAM2FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9714
PFNGLVERTEXSTREAM2DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble) # GL/glext.h:9715
PFNGLVERTEXSTREAM2DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:9716
PFNGLVERTEXSTREAM3SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # GL/glext.h:9717
PFNGLVERTEXSTREAM3SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:9718
PFNGLVERTEXSTREAM3IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # GL/glext.h:9719
PFNGLVERTEXSTREAM3IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9720
PFNGLVERTEXSTREAM3FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:9721
PFNGLVERTEXSTREAM3FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9722
PFNGLVERTEXSTREAM3DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:9723
PFNGLVERTEXSTREAM3DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:9724
PFNGLVERTEXSTREAM4SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort, GLshort) # GL/glext.h:9725
PFNGLVERTEXSTREAM4SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:9726
PFNGLVERTEXSTREAM4IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint, GLint) # GL/glext.h:9727
PFNGLVERTEXSTREAM4IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9728
PFNGLVERTEXSTREAM4FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:9729
PFNGLVERTEXSTREAM4FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9730
PFNGLVERTEXSTREAM4DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:9731
PFNGLVERTEXSTREAM4DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:9732
PFNGLNORMALSTREAM3BATIPROC = CFUNCTYPE(None, GLenum, GLbyte, GLbyte, GLbyte) # GL/glext.h:9733
PFNGLNORMALSTREAM3BVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLbyte)) # GL/glext.h:9734
PFNGLNORMALSTREAM3SATIPROC = CFUNCTYPE(None, GLenum, GLshort, GLshort, GLshort) # GL/glext.h:9735
PFNGLNORMALSTREAM3SVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLshort)) # GL/glext.h:9736
PFNGLNORMALSTREAM3IATIPROC = CFUNCTYPE(None, GLenum, GLint, GLint, GLint) # GL/glext.h:9737
PFNGLNORMALSTREAM3IVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9738
PFNGLNORMALSTREAM3FATIPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:9739
PFNGLNORMALSTREAM3FVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:9740
PFNGLNORMALSTREAM3DATIPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:9741
PFNGLNORMALSTREAM3DVATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:9742
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:9743
PFNGLVERTEXBLENDENVIATIPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9744
PFNGLVERTEXBLENDENVFATIPROC = CFUNCTYPE(None, GLenum, GLfloat) # GL/glext.h:9745
# ATI_element_array (GL/glext.h:9748)
GL_ATI_element_array = 1 # GL/glext.h:9749
# GL/glext.h:9751
glElementPointerATI = _link_function('glElementPointerATI', None, [GLenum, POINTER(GLvoid)], 'ATI_element_array')
# GL/glext.h:9752
glDrawElementArrayATI = _link_function('glDrawElementArrayATI', None, [GLenum, GLsizei], 'ATI_element_array')
# GL/glext.h:9753
glDrawRangeElementArrayATI = _link_function('glDrawRangeElementArrayATI', None, [GLenum, GLuint, GLuint, GLsizei], 'ATI_element_array')
PFNGLELEMENTPOINTERATIPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:9755
PFNGLDRAWELEMENTARRAYATIPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:9756
PFNGLDRAWRANGEELEMENTARRAYATIPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei) # GL/glext.h:9757
# SUN_mesh_array (GL/glext.h:9760)
GL_SUN_mesh_array = 1 # GL/glext.h:9761
# GL/glext.h:9763
glDrawMeshArraysSUN = _link_function('glDrawMeshArraysSUN', None, [GLenum, GLint, GLsizei, GLsizei], 'SUN_mesh_array')
PFNGLDRAWMESHARRAYSSUNPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:9765
# SUN_slice_accum (GL/glext.h:9768)
GL_SUN_slice_accum = 1 # GL/glext.h:9769
# NV_multisample_filter_hint (GL/glext.h:9772)
GL_NV_multisample_filter_hint = 1 # GL/glext.h:9773
# NV_depth_clamp (GL/glext.h:9776)
GL_NV_depth_clamp = 1 # GL/glext.h:9777
# NV_occlusion_query (GL/glext.h:9780)
GL_NV_occlusion_query = 1 # GL/glext.h:9781
# GL/glext.h:9783
glGenOcclusionQueriesNV = _link_function('glGenOcclusionQueriesNV', None, [GLsizei, POINTER(GLuint)], 'NV_occlusion_query')
# GL/glext.h:9784
glDeleteOcclusionQueriesNV = _link_function('glDeleteOcclusionQueriesNV', None, [GLsizei, POINTER(GLuint)], 'NV_occlusion_query')
# GL/glext.h:9785
glIsOcclusionQueryNV = _link_function('glIsOcclusionQueryNV', GLboolean, [GLuint], 'NV_occlusion_query')
# GL/glext.h:9786
glBeginOcclusionQueryNV = _link_function('glBeginOcclusionQueryNV', None, [GLuint], 'NV_occlusion_query')
# GL/glext.h:9787
glEndOcclusionQueryNV = _link_function('glEndOcclusionQueryNV', None, [], 'NV_occlusion_query')
# GL/glext.h:9788
glGetOcclusionQueryivNV = _link_function('glGetOcclusionQueryivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_occlusion_query')
# GL/glext.h:9789
glGetOcclusionQueryuivNV = _link_function('glGetOcclusionQueryuivNV', None, [GLuint, GLenum, POINTER(GLuint)], 'NV_occlusion_query')
PFNGLGENOCCLUSIONQUERIESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9791
PFNGLDELETEOCCLUSIONQUERIESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9792
PFNGLISOCCLUSIONQUERYNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9793
PFNGLBEGINOCCLUSIONQUERYNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9794
PFNGLENDOCCLUSIONQUERYNVPROC = CFUNCTYPE(None) # GL/glext.h:9795
PFNGLGETOCCLUSIONQUERYIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:9796
PFNGLGETOCCLUSIONQUERYUIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:9797
# NV_point_sprite (GL/glext.h:9800)
GL_NV_point_sprite = 1 # GL/glext.h:9801
# GL/glext.h:9803
glPointParameteriNV = _link_function('glPointParameteriNV', None, [GLenum, GLint], 'NV_point_sprite')
# GL/glext.h:9804
glPointParameterivNV = _link_function('glPointParameterivNV', None, [GLenum, POINTER(GLint)], 'NV_point_sprite')
PFNGLPOINTPARAMETERINVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9806
PFNGLPOINTPARAMETERIVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLint)) # GL/glext.h:9807
# NV_texture_shader3 (GL/glext.h:9810)
GL_NV_texture_shader3 = 1 # GL/glext.h:9811
# NV_vertex_program1_1 (GL/glext.h:9814)
GL_NV_vertex_program1_1 = 1 # GL/glext.h:9815
# EXT_shadow_funcs (GL/glext.h:9818)
GL_EXT_shadow_funcs = 1 # GL/glext.h:9819
# EXT_stencil_two_side (GL/glext.h:9822)
GL_EXT_stencil_two_side = 1 # GL/glext.h:9823
# GL/glext.h:9825
glActiveStencilFaceEXT = _link_function('glActiveStencilFaceEXT', None, [GLenum], 'EXT_stencil_two_side')
PFNGLACTIVESTENCILFACEEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:9827
# ATI_text_fragment_shader (GL/glext.h:9830)
GL_ATI_text_fragment_shader = 1 # GL/glext.h:9831
# APPLE_client_storage (GL/glext.h:9834)
GL_APPLE_client_storage = 1 # GL/glext.h:9835
# APPLE_element_array (GL/glext.h:9838)
GL_APPLE_element_array = 1 # GL/glext.h:9839
# GL/glext.h:9841
glElementPointerAPPLE = _link_function('glElementPointerAPPLE', None, [GLenum, POINTER(GLvoid)], 'APPLE_element_array')
# GL/glext.h:9842
glDrawElementArrayAPPLE = _link_function('glDrawElementArrayAPPLE', None, [GLenum, GLint, GLsizei], 'APPLE_element_array')
# GL/glext.h:9843
glDrawRangeElementArrayAPPLE = _link_function('glDrawRangeElementArrayAPPLE', None, [GLenum, GLuint, GLuint, GLint, GLsizei], 'APPLE_element_array')
# GL/glext.h:9844
glMultiDrawElementArrayAPPLE = _link_function('glMultiDrawElementArrayAPPLE', None, [GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei], 'APPLE_element_array')
# GL/glext.h:9845
glMultiDrawRangeElementArrayAPPLE = _link_function('glMultiDrawRangeElementArrayAPPLE', None, [GLenum, GLuint, GLuint, POINTER(GLint), POINTER(GLsizei), GLsizei], 'APPLE_element_array')
PFNGLELEMENTPOINTERAPPLEPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid)) # GL/glext.h:9847
PFNGLDRAWELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei) # GL/glext.h:9848
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLint, GLsizei) # GL/glext.h:9849
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:9850
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, POINTER(GLint), POINTER(GLsizei), GLsizei) # GL/glext.h:9851
# APPLE_fence (GL/glext.h:9854)
GL_APPLE_fence = 1 # GL/glext.h:9855
# GL/glext.h:9857
glGenFencesAPPLE = _link_function('glGenFencesAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_fence')
# GL/glext.h:9858
glDeleteFencesAPPLE = _link_function('glDeleteFencesAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_fence')
# GL/glext.h:9859
glSetFenceAPPLE = _link_function('glSetFenceAPPLE', None, [GLuint], 'APPLE_fence')
# GL/glext.h:9860
glIsFenceAPPLE = _link_function('glIsFenceAPPLE', GLboolean, [GLuint], 'APPLE_fence')
# GL/glext.h:9861
glTestFenceAPPLE = _link_function('glTestFenceAPPLE', GLboolean, [GLuint], 'APPLE_fence')
# GL/glext.h:9862
glFinishFenceAPPLE = _link_function('glFinishFenceAPPLE', None, [GLuint], 'APPLE_fence')
# GL/glext.h:9863
glTestObjectAPPLE = _link_function('glTestObjectAPPLE', GLboolean, [GLenum, GLuint], 'APPLE_fence')
# GL/glext.h:9864
glFinishObjectAPPLE = _link_function('glFinishObjectAPPLE', None, [GLenum, GLint], 'APPLE_fence')
PFNGLGENFENCESAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9866
PFNGLDELETEFENCESAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9867
PFNGLSETFENCEAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9868
PFNGLISFENCEAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9869
PFNGLTESTFENCEAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9870
PFNGLFINISHFENCEAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9871
PFNGLTESTOBJECTAPPLEPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:9872
PFNGLFINISHOBJECTAPPLEPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9873
# APPLE_vertex_array_object (GL/glext.h:9876)
GL_APPLE_vertex_array_object = 1 # GL/glext.h:9877
# GL/glext.h:9879
glBindVertexArrayAPPLE = _link_function('glBindVertexArrayAPPLE', None, [GLuint], 'APPLE_vertex_array_object')
# GL/glext.h:9880
glDeleteVertexArraysAPPLE = _link_function('glDeleteVertexArraysAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_vertex_array_object')
# GL/glext.h:9881
glGenVertexArraysAPPLE = _link_function('glGenVertexArraysAPPLE', None, [GLsizei, POINTER(GLuint)], 'APPLE_vertex_array_object')
# GL/glext.h:9882
glIsVertexArrayAPPLE = _link_function('glIsVertexArrayAPPLE', GLboolean, [GLuint], 'APPLE_vertex_array_object')
PFNGLBINDVERTEXARRAYAPPLEPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:9884
PFNGLDELETEVERTEXARRAYSAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9885
PFNGLGENVERTEXARRAYSAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:9886
PFNGLISVERTEXARRAYAPPLEPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:9887
# APPLE_vertex_array_range (GL/glext.h:9890)
GL_APPLE_vertex_array_range = 1 # GL/glext.h:9891
# GL/glext.h:9893
glVertexArrayRangeAPPLE = _link_function('glVertexArrayRangeAPPLE', None, [GLsizei, POINTER(GLvoid)], 'APPLE_vertex_array_range')
# GL/glext.h:9894
glFlushVertexArrayRangeAPPLE = _link_function('glFlushVertexArrayRangeAPPLE', None, [GLsizei, POINTER(GLvoid)], 'APPLE_vertex_array_range')
# GL/glext.h:9895
glVertexArrayParameteriAPPLE = _link_function('glVertexArrayParameteriAPPLE', None, [GLenum, GLint], 'APPLE_vertex_array_range')
PFNGLVERTEXARRAYRANGEAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:9897
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:9898
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:9899
# APPLE_ycbcr_422 (GL/glext.h:9902)
GL_APPLE_ycbcr_422 = 1 # GL/glext.h:9903
# S3_s3tc (GL/glext.h:9906)
GL_S3_s3tc = 1 # GL/glext.h:9907
# ATI_draw_buffers (GL/glext.h:9910)
GL_ATI_draw_buffers = 1 # GL/glext.h:9911
# GL/glext.h:9913
glDrawBuffersATI = _link_function('glDrawBuffersATI', None, [GLsizei, POINTER(GLenum)], 'ATI_draw_buffers')
PFNGLDRAWBUFFERSATIPROC = CFUNCTYPE(None, GLsizei, POINTER(GLenum)) # GL/glext.h:9915
# ATI_pixel_format_float (GL/glext.h:9918)
GL_ATI_pixel_format_float = 1 # GL/glext.h:9919
# ATI_texture_env_combine3 (GL/glext.h:9925)
GL_ATI_texture_env_combine3 = 1 # GL/glext.h:9926
# ATI_texture_float (GL/glext.h:9929)
GL_ATI_texture_float = 1 # GL/glext.h:9930
# NV_float_buffer (GL/glext.h:9933)
GL_NV_float_buffer = 1 # GL/glext.h:9934
# NV_fragment_program (GL/glext.h:9937)
GL_NV_fragment_program = 1 # GL/glext.h:9938
# GL/glext.h:9941
glProgramNamedParameter4fNV = _link_function('glProgramNamedParameter4fNV', None, [GLuint, GLsizei, POINTER(GLubyte), GLfloat, GLfloat, GLfloat, GLfloat], 'NV_fragment_program')
# GL/glext.h:9942
glProgramNamedParameter4dNV = _link_function('glProgramNamedParameter4dNV', None, [GLuint, GLsizei, POINTER(GLubyte), GLdouble, GLdouble, GLdouble, GLdouble], 'NV_fragment_program')
# GL/glext.h:9943
glProgramNamedParameter4fvNV = _link_function('glProgramNamedParameter4fvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)], 'NV_fragment_program')
# GL/glext.h:9944
glProgramNamedParameter4dvNV = _link_function('glProgramNamedParameter4dvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)], 'NV_fragment_program')
# GL/glext.h:9945
glGetProgramNamedParameterfvNV = _link_function('glGetProgramNamedParameterfvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)], 'NV_fragment_program')
# GL/glext.h:9946
glGetProgramNamedParameterdvNV = _link_function('glGetProgramNamedParameterdvNV', None, [GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)], 'NV_fragment_program')
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:9948
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:9949
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:9950
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)) # GL/glext.h:9951
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLfloat)) # GL/glext.h:9952
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), POINTER(GLdouble)) # GL/glext.h:9953
# NV_half_float (GL/glext.h:9956)
GL_NV_half_float = 1 # GL/glext.h:9957
# GL/glext.h:9959
glVertex2hNV = _link_function('glVertex2hNV', None, [GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9960
glVertex2hvNV = _link_function('glVertex2hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9961
glVertex3hNV = _link_function('glVertex3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9962
glVertex3hvNV = _link_function('glVertex3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9963
glVertex4hNV = _link_function('glVertex4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9964
glVertex4hvNV = _link_function('glVertex4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9965
glNormal3hNV = _link_function('glNormal3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9966
glNormal3hvNV = _link_function('glNormal3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9967
glColor3hNV = _link_function('glColor3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9968
glColor3hvNV = _link_function('glColor3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9969
glColor4hNV = _link_function('glColor4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9970
glColor4hvNV = _link_function('glColor4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9971
glTexCoord1hNV = _link_function('glTexCoord1hNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:9972
glTexCoord1hvNV = _link_function('glTexCoord1hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9973
glTexCoord2hNV = _link_function('glTexCoord2hNV', None, [GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9974
glTexCoord2hvNV = _link_function('glTexCoord2hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9975
glTexCoord3hNV = _link_function('glTexCoord3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9976
glTexCoord3hvNV = _link_function('glTexCoord3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9977
glTexCoord4hNV = _link_function('glTexCoord4hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9978
glTexCoord4hvNV = _link_function('glTexCoord4hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9979
glMultiTexCoord1hNV = _link_function('glMultiTexCoord1hNV', None, [GLenum, GLhalfNV], 'NV_half_float')
# GL/glext.h:9980
glMultiTexCoord1hvNV = _link_function('glMultiTexCoord1hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9981
glMultiTexCoord2hNV = _link_function('glMultiTexCoord2hNV', None, [GLenum, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9982
glMultiTexCoord2hvNV = _link_function('glMultiTexCoord2hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9983
glMultiTexCoord3hNV = _link_function('glMultiTexCoord3hNV', None, [GLenum, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9984
glMultiTexCoord3hvNV = _link_function('glMultiTexCoord3hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9985
glMultiTexCoord4hNV = _link_function('glMultiTexCoord4hNV', None, [GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9986
glMultiTexCoord4hvNV = _link_function('glMultiTexCoord4hvNV', None, [GLenum, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9987
glFogCoordhNV = _link_function('glFogCoordhNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:9988
glFogCoordhvNV = _link_function('glFogCoordhvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9989
glSecondaryColor3hNV = _link_function('glSecondaryColor3hNV', None, [GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9990
glSecondaryColor3hvNV = _link_function('glSecondaryColor3hvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9991
glVertexWeighthNV = _link_function('glVertexWeighthNV', None, [GLhalfNV], 'NV_half_float')
# GL/glext.h:9992
glVertexWeighthvNV = _link_function('glVertexWeighthvNV', None, [POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9993
glVertexAttrib1hNV = _link_function('glVertexAttrib1hNV', None, [GLuint, GLhalfNV], 'NV_half_float')
# GL/glext.h:9994
glVertexAttrib1hvNV = _link_function('glVertexAttrib1hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9995
glVertexAttrib2hNV = _link_function('glVertexAttrib2hNV', None, [GLuint, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9996
glVertexAttrib2hvNV = _link_function('glVertexAttrib2hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9997
glVertexAttrib3hNV = _link_function('glVertexAttrib3hNV', None, [GLuint, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:9998
glVertexAttrib3hvNV = _link_function('glVertexAttrib3hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:9999
glVertexAttrib4hNV = _link_function('glVertexAttrib4hNV', None, [GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV], 'NV_half_float')
# GL/glext.h:10000
glVertexAttrib4hvNV = _link_function('glVertexAttrib4hvNV', None, [GLuint, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:10001
glVertexAttribs1hvNV = _link_function('glVertexAttribs1hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:10002
glVertexAttribs2hvNV = _link_function('glVertexAttribs2hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:10003
glVertexAttribs3hvNV = _link_function('glVertexAttribs3hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
# GL/glext.h:10004
glVertexAttribs4hvNV = _link_function('glVertexAttribs4hvNV', None, [GLuint, GLsizei, POINTER(GLhalfNV)], 'NV_half_float')
PFNGLVERTEX2HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV) # GL/glext.h:10006
PFNGLVERTEX2HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10007
PFNGLVERTEX3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10008
PFNGLVERTEX3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10009
PFNGLVERTEX4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10010
PFNGLVERTEX4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10011
PFNGLNORMAL3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10012
PFNGLNORMAL3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10013
PFNGLCOLOR3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10014
PFNGLCOLOR3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10015
PFNGLCOLOR4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10016
PFNGLCOLOR4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10017
PFNGLTEXCOORD1HNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:10018
PFNGLTEXCOORD1HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10019
PFNGLTEXCOORD2HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV) # GL/glext.h:10020
PFNGLTEXCOORD2HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10021
PFNGLTEXCOORD3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10022
PFNGLTEXCOORD3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10023
PFNGLTEXCOORD4HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10024
PFNGLTEXCOORD4HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10025
PFNGLMULTITEXCOORD1HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV) # GL/glext.h:10026
PFNGLMULTITEXCOORD1HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:10027
PFNGLMULTITEXCOORD2HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV) # GL/glext.h:10028
PFNGLMULTITEXCOORD2HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:10029
PFNGLMULTITEXCOORD3HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10030
PFNGLMULTITEXCOORD3HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:10031
PFNGLMULTITEXCOORD4HNVPROC = CFUNCTYPE(None, GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10032
PFNGLMULTITEXCOORD4HVNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLhalfNV)) # GL/glext.h:10033
PFNGLFOGCOORDHNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:10034
PFNGLFOGCOORDHVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10035
PFNGLSECONDARYCOLOR3HNVPROC = CFUNCTYPE(None, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10036
PFNGLSECONDARYCOLOR3HVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10037
PFNGLVERTEXWEIGHTHNVPROC = CFUNCTYPE(None, GLhalfNV) # GL/glext.h:10038
PFNGLVERTEXWEIGHTHVNVPROC = CFUNCTYPE(None, POINTER(GLhalfNV)) # GL/glext.h:10039
PFNGLVERTEXATTRIB1HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV) # GL/glext.h:10040
PFNGLVERTEXATTRIB1HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:10041
PFNGLVERTEXATTRIB2HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV) # GL/glext.h:10042
PFNGLVERTEXATTRIB2HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:10043
PFNGLVERTEXATTRIB3HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10044
PFNGLVERTEXATTRIB3HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:10045
PFNGLVERTEXATTRIB4HNVPROC = CFUNCTYPE(None, GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV) # GL/glext.h:10046
PFNGLVERTEXATTRIB4HVNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLhalfNV)) # GL/glext.h:10047
PFNGLVERTEXATTRIBS1HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:10048
PFNGLVERTEXATTRIBS2HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:10049
PFNGLVERTEXATTRIBS3HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:10050
PFNGLVERTEXATTRIBS4HVNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLhalfNV)) # GL/glext.h:10051
# NV_pixel_data_range (GL/glext.h:10054)
GL_NV_pixel_data_range = 1 # GL/glext.h:10055
# GL/glext.h:10057
glPixelDataRangeNV = _link_function('glPixelDataRangeNV', None, [GLenum, GLsizei, POINTER(GLvoid)], 'NV_pixel_data_range')
# GL/glext.h:10058
glFlushPixelDataRangeNV = _link_function('glFlushPixelDataRangeNV', None, [GLenum], 'NV_pixel_data_range')
PFNGLPIXELDATARANGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10060
PFNGLFLUSHPIXELDATARANGENVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10061
# NV_primitive_restart (GL/glext.h:10064)
GL_NV_primitive_restart = 1 # GL/glext.h:10065
# GL/glext.h:10067
glPrimitiveRestartNV = _link_function('glPrimitiveRestartNV', None, [], 'NV_primitive_restart')
# GL/glext.h:10068
glPrimitiveRestartIndexNV = _link_function('glPrimitiveRestartIndexNV', None, [GLuint], 'NV_primitive_restart')
PFNGLPRIMITIVERESTARTNVPROC = CFUNCTYPE(None) # GL/glext.h:10070
PFNGLPRIMITIVERESTARTINDEXNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:10071
# NV_texture_expand_normal (GL/glext.h:10074)
GL_NV_texture_expand_normal = 1 # GL/glext.h:10075
# NV_vertex_program2 (GL/glext.h:10078)
GL_NV_vertex_program2 = 1 # GL/glext.h:10079
# ATI_map_object_buffer (GL/glext.h:10082)
GL_ATI_map_object_buffer = 1 # GL/glext.h:10083
# GL/glext.h:10085
glMapObjectBufferATI = _link_function('glMapObjectBufferATI', POINTER(GLvoid), [GLuint], 'ATI_map_object_buffer')
# GL/glext.h:10086
glUnmapObjectBufferATI = _link_function('glUnmapObjectBufferATI', None, [GLuint], 'ATI_map_object_buffer')
PFNGLMAPOBJECTBUFFERATIPROC = CFUNCTYPE(POINTER(GLvoid), GLuint) # GL/glext.h:10088
PFNGLUNMAPOBJECTBUFFERATIPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:10089
# ATI_separate_stencil (GL/glext.h:10092)
GL_ATI_separate_stencil = 1 # GL/glext.h:10093
# GL/glext.h:10095
glStencilOpSeparateATI = _link_function('glStencilOpSeparateATI', None, [GLenum, GLenum, GLenum, GLenum], 'ATI_separate_stencil')
# GL/glext.h:10096
glStencilFuncSeparateATI = _link_function('glStencilFuncSeparateATI', None, [GLenum, GLenum, GLint, GLuint], 'ATI_separate_stencil')
PFNGLSTENCILOPSEPARATEATIPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:10098
PFNGLSTENCILFUNCSEPARATEATIPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLuint) # GL/glext.h:10099
# ATI_vertex_attrib_array_object (GL/glext.h:10102)
GL_ATI_vertex_attrib_array_object = 1 # GL/glext.h:10103
# GL/glext.h:10105
glVertexAttribArrayObjectATI = _link_function('glVertexAttribArrayObjectATI', None, [GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint], 'ATI_vertex_attrib_array_object')
# GL/glext.h:10106
glGetVertexAttribArrayObjectfvATI = _link_function('glGetVertexAttribArrayObjectfvATI', None, [GLuint, GLenum, POINTER(GLfloat)], 'ATI_vertex_attrib_array_object')
# GL/glext.h:10107
glGetVertexAttribArrayObjectivATI = _link_function('glGetVertexAttribArrayObjectivATI', None, [GLuint, GLenum, POINTER(GLint)], 'ATI_vertex_attrib_array_object')
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint) # GL/glext.h:10109
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:10110
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:10111
# OES_read_format (GL/glext.h:10114)
GL_OES_read_format = 1 # GL/glext.h:10115
# EXT_depth_bounds_test (GL/glext.h:10118)
GL_EXT_depth_bounds_test = 1 # GL/glext.h:10119
GLclampd = c_double # /usr/include/GL/gl.h:163
# GL/glext.h:10121
glDepthBoundsEXT = _link_function('glDepthBoundsEXT', None, [GLclampd, GLclampd], 'EXT_depth_bounds_test')
PFNGLDEPTHBOUNDSEXTPROC = CFUNCTYPE(None, GLclampd, GLclampd) # GL/glext.h:10123
# EXT_texture_mirror_clamp (GL/glext.h:10126)
GL_EXT_texture_mirror_clamp = 1 # GL/glext.h:10127
# EXT_blend_equation_separate (GL/glext.h:10130)
GL_EXT_blend_equation_separate = 1 # GL/glext.h:10131
# GL/glext.h:10133
glBlendEquationSeparateEXT = _link_function('glBlendEquationSeparateEXT', None, [GLenum, GLenum], 'EXT_blend_equation_separate')
PFNGLBLENDEQUATIONSEPARATEEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:10135
# MESA_pack_invert (GL/glext.h:10138)
GL_MESA_pack_invert = 1 # GL/glext.h:10139
# MESA_ycbcr_texture (GL/glext.h:10142)
GL_MESA_ycbcr_texture = 1 # GL/glext.h:10143
# EXT_pixel_buffer_object (GL/glext.h:10146)
GL_EXT_pixel_buffer_object = 1 # GL/glext.h:10147
# NV_fragment_program_option (GL/glext.h:10150)
GL_NV_fragment_program_option = 1 # GL/glext.h:10151
# NV_fragment_program2 (GL/glext.h:10154)
GL_NV_fragment_program2 = 1 # GL/glext.h:10155
# NV_vertex_program2_option (GL/glext.h:10158)
GL_NV_vertex_program2_option = 1 # GL/glext.h:10159
# NV_vertex_program3 (GL/glext.h:10162)
GL_NV_vertex_program3 = 1 # GL/glext.h:10163
# EXT_framebuffer_object (GL/glext.h:10166)
GL_EXT_framebuffer_object = 1 # GL/glext.h:10167
# GL/glext.h:10169
glIsRenderbufferEXT = _link_function('glIsRenderbufferEXT', GLboolean, [GLuint], 'EXT_framebuffer_object')
# GL/glext.h:10170
glBindRenderbufferEXT = _link_function('glBindRenderbufferEXT', None, [GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:10171
glDeleteRenderbuffersEXT = _link_function('glDeleteRenderbuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:10172
glGenRenderbuffersEXT = _link_function('glGenRenderbuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:10173
glRenderbufferStorageEXT = _link_function('glRenderbufferStorageEXT', None, [GLenum, GLenum, GLsizei, GLsizei], 'EXT_framebuffer_object')
# GL/glext.h:10174
glGetRenderbufferParameterivEXT = _link_function('glGetRenderbufferParameterivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_framebuffer_object')
# GL/glext.h:10175
glIsFramebufferEXT = _link_function('glIsFramebufferEXT', GLboolean, [GLuint], 'EXT_framebuffer_object')
# GL/glext.h:10176
glBindFramebufferEXT = _link_function('glBindFramebufferEXT', None, [GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:10177
glDeleteFramebuffersEXT = _link_function('glDeleteFramebuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:10178
glGenFramebuffersEXT = _link_function('glGenFramebuffersEXT', None, [GLsizei, POINTER(GLuint)], 'EXT_framebuffer_object')
# GL/glext.h:10179
glCheckFramebufferStatusEXT = _link_function('glCheckFramebufferStatusEXT', GLenum, [GLenum], 'EXT_framebuffer_object')
# GL/glext.h:10180
glFramebufferTexture1DEXT = _link_function('glFramebufferTexture1DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:10181
glFramebufferTexture2DEXT = _link_function('glFramebufferTexture2DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:10182
glFramebufferTexture3DEXT = _link_function('glFramebufferTexture3DEXT', None, [GLenum, GLenum, GLenum, GLuint, GLint, GLint], 'EXT_framebuffer_object')
# GL/glext.h:10183
glFramebufferRenderbufferEXT = _link_function('glFramebufferRenderbufferEXT', None, [GLenum, GLenum, GLenum, GLuint], 'EXT_framebuffer_object')
# GL/glext.h:10184
glGetFramebufferAttachmentParameterivEXT = _link_function('glGetFramebufferAttachmentParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_framebuffer_object')
# GL/glext.h:10185
glGenerateMipmapEXT = _link_function('glGenerateMipmapEXT', None, [GLenum], 'EXT_framebuffer_object')
PFNGLISRENDERBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:10187
PFNGLBINDRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10188
PFNGLDELETERENDERBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:10189
PFNGLGENRENDERBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:10190
PFNGLRENDERBUFFERSTORAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, GLsizei) # GL/glext.h:10191
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10192
PFNGLISFRAMEBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:10193
PFNGLBINDFRAMEBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10194
PFNGLDELETEFRAMEBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:10195
PFNGLGENFRAMEBUFFERSEXTPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:10196
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = CFUNCTYPE(GLenum, GLenum) # GL/glext.h:10197
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:10198
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint) # GL/glext.h:10199
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:10200
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:10201
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10202
PFNGLGENERATEMIPMAPEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10203
# GREMEDY_string_marker (GL/glext.h:10206)
GL_GREMEDY_string_marker = 1 # GL/glext.h:10207
# GL/glext.h:10209
glStringMarkerGREMEDY = _link_function('glStringMarkerGREMEDY', None, [GLsizei, POINTER(GLvoid)], 'GREMEDY_string_marker')
PFNGLSTRINGMARKERGREMEDYPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvoid)) # GL/glext.h:10211
# EXT_packed_depth_stencil (GL/glext.h:10214)
GL_EXT_packed_depth_stencil = 1 # GL/glext.h:10215
# EXT_stencil_clear_tag (GL/glext.h:10218)
GL_EXT_stencil_clear_tag = 1 # GL/glext.h:10219
# GL/glext.h:10221
glStencilClearTagEXT = _link_function('glStencilClearTagEXT', None, [GLsizei, GLuint], 'EXT_stencil_clear_tag')
PFNGLSTENCILCLEARTAGEXTPROC = CFUNCTYPE(None, GLsizei, GLuint) # GL/glext.h:10223
# EXT_texture_sRGB (GL/glext.h:10226)
GL_EXT_texture_sRGB = 1 # GL/glext.h:10227
# EXT_framebuffer_blit (GL/glext.h:10230)
GL_EXT_framebuffer_blit = 1 # GL/glext.h:10231
# GL/glext.h:10233
glBlitFramebufferEXT = _link_function('glBlitFramebufferEXT', None, [GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum], 'EXT_framebuffer_blit')
PFNGLBLITFRAMEBUFFEREXTPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum) # GL/glext.h:10235
# EXT_framebuffer_multisample (GL/glext.h:10238)
GL_EXT_framebuffer_multisample = 1 # GL/glext.h:10239
# GL/glext.h:10241
glRenderbufferStorageMultisampleEXT = _link_function('glRenderbufferStorageMultisampleEXT', None, [GLenum, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_framebuffer_multisample')
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:10243
# MESAX_texture_stack (GL/glext.h:10246)
GL_MESAX_texture_stack = 1 # GL/glext.h:10247
# EXT_timer_query (GL/glext.h:10250)
GL_EXT_timer_query = 1 # GL/glext.h:10251
# GL/glext.h:10253
glGetQueryObjecti64vEXT = _link_function('glGetQueryObjecti64vEXT', None, [GLuint, GLenum, POINTER(GLint64EXT)], 'EXT_timer_query')
# GL/glext.h:10254
glGetQueryObjectui64vEXT = _link_function('glGetQueryObjectui64vEXT', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'EXT_timer_query')
PFNGLGETQUERYOBJECTI64VEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64EXT)) # GL/glext.h:10256
PFNGLGETQUERYOBJECTUI64VEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:10257
# EXT_gpu_program_parameters (GL/glext.h:10260)
GL_EXT_gpu_program_parameters = 1 # GL/glext.h:10261
# GL/glext.h:10263
glProgramEnvParameters4fvEXT = _link_function('glProgramEnvParameters4fvEXT', None, [GLenum, GLuint, GLsizei, POINTER(GLfloat)], 'EXT_gpu_program_parameters')
# GL/glext.h:10264
glProgramLocalParameters4fvEXT = _link_function('glProgramLocalParameters4fvEXT', None, [GLenum, GLuint, GLsizei, POINTER(GLfloat)], 'EXT_gpu_program_parameters')
PFNGLPROGRAMENVPARAMETERS4FVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10266
PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10267
# APPLE_flush_buffer_range (GL/glext.h:10270)
GL_APPLE_flush_buffer_range = 1 # GL/glext.h:10271
# GL/glext.h:10273
glBufferParameteriAPPLE = _link_function('glBufferParameteriAPPLE', None, [GLenum, GLenum, GLint], 'APPLE_flush_buffer_range')
# GL/glext.h:10274
glFlushMappedBufferRangeAPPLE = _link_function('glFlushMappedBufferRangeAPPLE', None, [GLenum, GLintptr, GLsizeiptr], 'APPLE_flush_buffer_range')
PFNGLBUFFERPARAMETERIAPPLEPROC = CFUNCTYPE(None, GLenum, GLenum, GLint) # GL/glext.h:10276
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC = CFUNCTYPE(None, GLenum, GLintptr, GLsizeiptr) # GL/glext.h:10277
# NV_gpu_program4 (GL/glext.h:10280)
GL_NV_gpu_program4 = 1 # GL/glext.h:10281
# GL/glext.h:10283
glProgramLocalParameterI4iNV = _link_function('glProgramLocalParameterI4iNV', None, [GLenum, GLuint, GLint, GLint, GLint, GLint], 'NV_gpu_program4')
# GL/glext.h:10284
glProgramLocalParameterI4ivNV = _link_function('glProgramLocalParameterI4ivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10285
glProgramLocalParametersI4ivNV = _link_function('glProgramLocalParametersI4ivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10286
glProgramLocalParameterI4uiNV = _link_function('glProgramLocalParameterI4uiNV', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'NV_gpu_program4')
# GL/glext.h:10287
glProgramLocalParameterI4uivNV = _link_function('glProgramLocalParameterI4uivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:10288
glProgramLocalParametersI4uivNV = _link_function('glProgramLocalParametersI4uivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:10289
glProgramEnvParameterI4iNV = _link_function('glProgramEnvParameterI4iNV', None, [GLenum, GLuint, GLint, GLint, GLint, GLint], 'NV_gpu_program4')
# GL/glext.h:10290
glProgramEnvParameterI4ivNV = _link_function('glProgramEnvParameterI4ivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10291
glProgramEnvParametersI4ivNV = _link_function('glProgramEnvParametersI4ivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10292
glProgramEnvParameterI4uiNV = _link_function('glProgramEnvParameterI4uiNV', None, [GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'NV_gpu_program4')
# GL/glext.h:10293
glProgramEnvParameterI4uivNV = _link_function('glProgramEnvParameterI4uivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:10294
glProgramEnvParametersI4uivNV = _link_function('glProgramEnvParametersI4uivNV', None, [GLenum, GLuint, GLsizei, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:10295
glGetProgramLocalParameterIivNV = _link_function('glGetProgramLocalParameterIivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10296
glGetProgramLocalParameterIuivNV = _link_function('glGetProgramLocalParameterIuivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
# GL/glext.h:10297
glGetProgramEnvParameterIivNV = _link_function('glGetProgramEnvParameterIivNV', None, [GLenum, GLuint, POINTER(GLint)], 'NV_gpu_program4')
# GL/glext.h:10298
glGetProgramEnvParameterIuivNV = _link_function('glGetProgramEnvParameterIuivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program4')
PFNGLPROGRAMLOCALPARAMETERI4INVPROC = CFUNCTYPE(None, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:10300
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10301
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:10302
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10303
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10304
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:10305
PFNGLPROGRAMENVPARAMETERI4INVPROC = CFUNCTYPE(None, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:10306
PFNGLPROGRAMENVPARAMETERI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10307
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:10308
PFNGLPROGRAMENVPARAMETERI4UINVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10309
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10310
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:10311
PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10312
PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10313
PFNGLGETPROGRAMENVPARAMETERIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10314
PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10315
# NV_geometry_program4 (GL/glext.h:10318)
GL_NV_geometry_program4 = 1 # GL/glext.h:10319
# GL/glext.h:10321
glProgramVertexLimitNV = _link_function('glProgramVertexLimitNV', None, [GLenum, GLint], 'NV_geometry_program4')
# GL/glext.h:10322
glFramebufferTextureEXT = _link_function('glFramebufferTextureEXT', None, [GLenum, GLenum, GLuint, GLint], 'NV_geometry_program4')
# GL/glext.h:10323
glFramebufferTextureLayerEXT = _link_function('glFramebufferTextureLayerEXT', None, [GLenum, GLenum, GLuint, GLint, GLint], 'NV_geometry_program4')
# GL/glext.h:10324
glFramebufferTextureFaceEXT = _link_function('glFramebufferTextureFaceEXT', None, [GLenum, GLenum, GLuint, GLint, GLenum], 'NV_geometry_program4')
PFNGLPROGRAMVERTEXLIMITNVPROC = CFUNCTYPE(None, GLenum, GLint) # GL/glext.h:10326
PFNGLFRAMEBUFFERTEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint) # GL/glext.h:10327
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:10328
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLint, GLenum) # GL/glext.h:10329
# EXT_geometry_shader4 (GL/glext.h:10332)
GL_EXT_geometry_shader4 = 1 # GL/glext.h:10333
# GL/glext.h:10335
glProgramParameteriEXT = _link_function('glProgramParameteriEXT', None, [GLuint, GLenum, GLint], 'EXT_geometry_shader4')
PFNGLPROGRAMPARAMETERIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:10337
# NV_vertex_program4 (GL/glext.h:10340)
GL_NV_vertex_program4 = 1 # GL/glext.h:10341
# GL/glext.h:10343
glVertexAttribI1iEXT = _link_function('glVertexAttribI1iEXT', None, [GLuint, GLint], 'NV_vertex_program4')
# GL/glext.h:10344
glVertexAttribI2iEXT = _link_function('glVertexAttribI2iEXT', None, [GLuint, GLint, GLint], 'NV_vertex_program4')
# GL/glext.h:10345
glVertexAttribI3iEXT = _link_function('glVertexAttribI3iEXT', None, [GLuint, GLint, GLint, GLint], 'NV_vertex_program4')
# GL/glext.h:10346
glVertexAttribI4iEXT = _link_function('glVertexAttribI4iEXT', None, [GLuint, GLint, GLint, GLint, GLint], 'NV_vertex_program4')
# GL/glext.h:10347
glVertexAttribI1uiEXT = _link_function('glVertexAttribI1uiEXT', None, [GLuint, GLuint], 'NV_vertex_program4')
# GL/glext.h:10348
glVertexAttribI2uiEXT = _link_function('glVertexAttribI2uiEXT', None, [GLuint, GLuint, GLuint], 'NV_vertex_program4')
# GL/glext.h:10349
glVertexAttribI3uiEXT = _link_function('glVertexAttribI3uiEXT', None, [GLuint, GLuint, GLuint, GLuint], 'NV_vertex_program4')
# GL/glext.h:10350
glVertexAttribI4uiEXT = _link_function('glVertexAttribI4uiEXT', None, [GLuint, GLuint, GLuint, GLuint, GLuint], 'NV_vertex_program4')
# GL/glext.h:10351
glVertexAttribI1ivEXT = _link_function('glVertexAttribI1ivEXT', None, [GLuint, POINTER(GLint)], 'NV_vertex_program4')
# GL/glext.h:10352
glVertexAttribI2ivEXT = _link_function('glVertexAttribI2ivEXT', None, [GLuint, POINTER(GLint)], 'NV_vertex_program4')
# GL/glext.h:10353
glVertexAttribI3ivEXT = _link_function('glVertexAttribI3ivEXT', None, [GLuint, POINTER(GLint)], 'NV_vertex_program4')
# GL/glext.h:10354
glVertexAttribI4ivEXT = _link_function('glVertexAttribI4ivEXT', None, [GLuint, POINTER(GLint)], 'NV_vertex_program4')
# GL/glext.h:10355
glVertexAttribI1uivEXT = _link_function('glVertexAttribI1uivEXT', None, [GLuint, POINTER(GLuint)], 'NV_vertex_program4')
# GL/glext.h:10356
glVertexAttribI2uivEXT = _link_function('glVertexAttribI2uivEXT', None, [GLuint, POINTER(GLuint)], 'NV_vertex_program4')
# GL/glext.h:10357
glVertexAttribI3uivEXT = _link_function('glVertexAttribI3uivEXT', None, [GLuint, POINTER(GLuint)], 'NV_vertex_program4')
# GL/glext.h:10358
glVertexAttribI4uivEXT = _link_function('glVertexAttribI4uivEXT', None, [GLuint, POINTER(GLuint)], 'NV_vertex_program4')
# GL/glext.h:10359
glVertexAttribI4bvEXT = _link_function('glVertexAttribI4bvEXT', None, [GLuint, POINTER(GLbyte)], 'NV_vertex_program4')
# GL/glext.h:10360
glVertexAttribI4svEXT = _link_function('glVertexAttribI4svEXT', None, [GLuint, POINTER(GLshort)], 'NV_vertex_program4')
# GL/glext.h:10361
glVertexAttribI4ubvEXT = _link_function('glVertexAttribI4ubvEXT', None, [GLuint, POINTER(GLubyte)], 'NV_vertex_program4')
# GL/glext.h:10362
glVertexAttribI4usvEXT = _link_function('glVertexAttribI4usvEXT', None, [GLuint, POINTER(GLushort)], 'NV_vertex_program4')
# GL/glext.h:10363
glVertexAttribIPointerEXT = _link_function('glVertexAttribIPointerEXT', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'NV_vertex_program4')
# GL/glext.h:10364
glGetVertexAttribIivEXT = _link_function('glGetVertexAttribIivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'NV_vertex_program4')
# GL/glext.h:10365
glGetVertexAttribIuivEXT = _link_function('glGetVertexAttribIuivEXT', None, [GLuint, GLenum, POINTER(GLuint)], 'NV_vertex_program4')
PFNGLVERTEXATTRIBI1IEXTPROC = CFUNCTYPE(None, GLuint, GLint) # GL/glext.h:10367
PFNGLVERTEXATTRIBI2IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:10368
PFNGLVERTEXATTRIBI3IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:10369
PFNGLVERTEXATTRIBI4IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:10370
PFNGLVERTEXATTRIBI1UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:10371
PFNGLVERTEXATTRIBI2UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint) # GL/glext.h:10372
PFNGLVERTEXATTRIBI3UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10373
PFNGLVERTEXATTRIBI4UIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10374
PFNGLVERTEXATTRIBI1IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:10375
PFNGLVERTEXATTRIBI2IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:10376
PFNGLVERTEXATTRIBI3IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:10377
PFNGLVERTEXATTRIBI4IVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLint)) # GL/glext.h:10378
PFNGLVERTEXATTRIBI1UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:10379
PFNGLVERTEXATTRIBI2UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:10380
PFNGLVERTEXATTRIBI3UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:10381
PFNGLVERTEXATTRIBI4UIVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint)) # GL/glext.h:10382
PFNGLVERTEXATTRIBI4BVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLbyte)) # GL/glext.h:10383
PFNGLVERTEXATTRIBI4SVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLshort)) # GL/glext.h:10384
PFNGLVERTEXATTRIBI4UBVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:10385
PFNGLVERTEXATTRIBI4USVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLushort)) # GL/glext.h:10386
PFNGLVERTEXATTRIBIPOINTEREXTPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10387
PFNGLGETVERTEXATTRIBIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:10388
PFNGLGETVERTEXATTRIBIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:10389
# EXT_gpu_shader4 (GL/glext.h:10392)
GL_EXT_gpu_shader4 = 1 # GL/glext.h:10393
# GL/glext.h:10395
glGetUniformuivEXT = _link_function('glGetUniformuivEXT', None, [GLuint, GLint, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:10396
glBindFragDataLocationEXT = _link_function('glBindFragDataLocationEXT', None, [GLuint, GLuint, POINTER(GLchar)], 'EXT_gpu_shader4')
# GL/glext.h:10397
glGetFragDataLocationEXT = _link_function('glGetFragDataLocationEXT', GLint, [GLuint, POINTER(GLchar)], 'EXT_gpu_shader4')
# GL/glext.h:10398
glUniform1uiEXT = _link_function('glUniform1uiEXT', None, [GLint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:10399
glUniform2uiEXT = _link_function('glUniform2uiEXT', None, [GLint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:10400
glUniform3uiEXT = _link_function('glUniform3uiEXT', None, [GLint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:10401
glUniform4uiEXT = _link_function('glUniform4uiEXT', None, [GLint, GLuint, GLuint, GLuint, GLuint], 'EXT_gpu_shader4')
# GL/glext.h:10402
glUniform1uivEXT = _link_function('glUniform1uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:10403
glUniform2uivEXT = _link_function('glUniform2uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:10404
glUniform3uivEXT = _link_function('glUniform3uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
# GL/glext.h:10405
glUniform4uivEXT = _link_function('glUniform4uivEXT', None, [GLint, GLsizei, POINTER(GLuint)], 'EXT_gpu_shader4')
PFNGLGETUNIFORMUIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint)) # GL/glext.h:10407
PFNGLBINDFRAGDATALOCATIONEXTPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLchar)) # GL/glext.h:10408
PFNGLGETFRAGDATALOCATIONEXTPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:10409
PFNGLUNIFORM1UIEXTPROC = CFUNCTYPE(None, GLint, GLuint) # GL/glext.h:10410
PFNGLUNIFORM2UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint) # GL/glext.h:10411
PFNGLUNIFORM3UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint) # GL/glext.h:10412
PFNGLUNIFORM4UIEXTPROC = CFUNCTYPE(None, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10413
PFNGLUNIFORM1UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10414
PFNGLUNIFORM2UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10415
PFNGLUNIFORM3UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10416
PFNGLUNIFORM4UIVEXTPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10417
# EXT_draw_instanced (GL/glext.h:10420)
GL_EXT_draw_instanced = 1 # GL/glext.h:10421
# GL/glext.h:10423
glDrawArraysInstancedEXT = _link_function('glDrawArraysInstancedEXT', None, [GLenum, GLint, GLsizei, GLsizei], 'EXT_draw_instanced')
# GL/glext.h:10424
glDrawElementsInstancedEXT = _link_function('glDrawElementsInstancedEXT', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei], 'EXT_draw_instanced')
PFNGLDRAWARRAYSINSTANCEDEXTPROC = CFUNCTYPE(None, GLenum, GLint, GLsizei, GLsizei) # GL/glext.h:10426
PFNGLDRAWELEMENTSINSTANCEDEXTPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLsizei) # GL/glext.h:10427
# EXT_packed_float (GL/glext.h:10430)
GL_EXT_packed_float = 1 # GL/glext.h:10431
# EXT_texture_array (GL/glext.h:10434)
GL_EXT_texture_array = 1 # GL/glext.h:10435
# EXT_texture_buffer_object (GL/glext.h:10438)
GL_EXT_texture_buffer_object = 1 # GL/glext.h:10439
# GL/glext.h:10441
glTexBufferEXT = _link_function('glTexBufferEXT', None, [GLenum, GLenum, GLuint], 'EXT_texture_buffer_object')
PFNGLTEXBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:10443
# EXT_texture_compression_latc (GL/glext.h:10446)
GL_EXT_texture_compression_latc = 1 # GL/glext.h:10447
# EXT_texture_compression_rgtc (GL/glext.h:10450)
GL_EXT_texture_compression_rgtc = 1 # GL/glext.h:10451
# EXT_texture_shared_exponent (GL/glext.h:10454)
GL_EXT_texture_shared_exponent = 1 # GL/glext.h:10455
# NV_depth_buffer_float (GL/glext.h:10458)
GL_NV_depth_buffer_float = 1 # GL/glext.h:10459
# GL/glext.h:10461
glDepthRangedNV = _link_function('glDepthRangedNV', None, [GLdouble, GLdouble], 'NV_depth_buffer_float')
# GL/glext.h:10462
glClearDepthdNV = _link_function('glClearDepthdNV', None, [GLdouble], 'NV_depth_buffer_float')
# GL/glext.h:10463
glDepthBoundsdNV = _link_function('glDepthBoundsdNV', None, [GLdouble, GLdouble], 'NV_depth_buffer_float')
PFNGLDEPTHRANGEDNVPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:10465
PFNGLCLEARDEPTHDNVPROC = CFUNCTYPE(None, GLdouble) # GL/glext.h:10466
PFNGLDEPTHBOUNDSDNVPROC = CFUNCTYPE(None, GLdouble, GLdouble) # GL/glext.h:10467
# NV_fragment_program4 (GL/glext.h:10470)
GL_NV_fragment_program4 = 1 # GL/glext.h:10471
# NV_framebuffer_multisample_coverage (GL/glext.h:10474)
GL_NV_framebuffer_multisample_coverage = 1 # GL/glext.h:10475
# GL/glext.h:10477
glRenderbufferStorageMultisampleCoverageNV = _link_function('glRenderbufferStorageMultisampleCoverageNV', None, [GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei], 'NV_framebuffer_multisample_coverage')
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:10479
# EXT_framebuffer_sRGB (GL/glext.h:10482)
GL_EXT_framebuffer_sRGB = 1 # GL/glext.h:10483
# NV_geometry_shader4 (GL/glext.h:10486)
GL_NV_geometry_shader4 = 1 # GL/glext.h:10487
# NV_parameter_buffer_object (GL/glext.h:10490)
GL_NV_parameter_buffer_object = 1 # GL/glext.h:10491
# GL/glext.h:10493
glProgramBufferParametersfvNV = _link_function('glProgramBufferParametersfvNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLfloat)], 'NV_parameter_buffer_object')
# GL/glext.h:10494
glProgramBufferParametersIivNV = _link_function('glProgramBufferParametersIivNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLint)], 'NV_parameter_buffer_object')
# GL/glext.h:10495
glProgramBufferParametersIuivNV = _link_function('glProgramBufferParametersIuivNV', None, [GLenum, GLuint, GLuint, GLsizei, POINTER(GLuint)], 'NV_parameter_buffer_object')
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10497
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:10498
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:10499
# EXT_draw_buffers2 (GL/glext.h:10502)
GL_EXT_draw_buffers2 = 1 # GL/glext.h:10503
# GL/glext.h:10505
glColorMaskIndexedEXT = _link_function('glColorMaskIndexedEXT', None, [GLuint, GLboolean, GLboolean, GLboolean, GLboolean], 'EXT_draw_buffers2')
# GL/glext.h:10506
glGetBooleanIndexedvEXT = _link_function('glGetBooleanIndexedvEXT', None, [GLenum, GLuint, POINTER(GLboolean)], 'EXT_draw_buffers2')
# GL/glext.h:10507
glGetIntegerIndexedvEXT = _link_function('glGetIntegerIndexedvEXT', None, [GLenum, GLuint, POINTER(GLint)], 'EXT_draw_buffers2')
# GL/glext.h:10508
glEnableIndexedEXT = _link_function('glEnableIndexedEXT', None, [GLenum, GLuint], 'EXT_draw_buffers2')
# GL/glext.h:10509
glDisableIndexedEXT = _link_function('glDisableIndexedEXT', None, [GLenum, GLuint], 'EXT_draw_buffers2')
# GL/glext.h:10510
glIsEnabledIndexedEXT = _link_function('glIsEnabledIndexedEXT', GLboolean, [GLenum, GLuint], 'EXT_draw_buffers2')
PFNGLCOLORMASKINDEXEDEXTPROC = CFUNCTYPE(None, GLuint, GLboolean, GLboolean, GLboolean, GLboolean) # GL/glext.h:10512
PFNGLGETBOOLEANINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLboolean)) # GL/glext.h:10513
PFNGLGETINTEGERINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10514
PFNGLENABLEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10515
PFNGLDISABLEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10516
PFNGLISENABLEDINDEXEDEXTPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:10517
# NV_transform_feedback (GL/glext.h:10520)
GL_NV_transform_feedback = 1 # GL/glext.h:10521
# GL/glext.h:10523
glBeginTransformFeedbackNV = _link_function('glBeginTransformFeedbackNV', None, [GLenum], 'NV_transform_feedback')
# GL/glext.h:10524
glEndTransformFeedbackNV = _link_function('glEndTransformFeedbackNV', None, [], 'NV_transform_feedback')
# GL/glext.h:10525
glTransformFeedbackAttribsNV = _link_function('glTransformFeedbackAttribsNV', None, [GLuint, POINTER(GLint), GLenum], 'NV_transform_feedback')
# GL/glext.h:10526
glBindBufferRangeNV = _link_function('glBindBufferRangeNV', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'NV_transform_feedback')
# GL/glext.h:10527
glBindBufferOffsetNV = _link_function('glBindBufferOffsetNV', None, [GLenum, GLuint, GLuint, GLintptr], 'NV_transform_feedback')
# GL/glext.h:10528
glBindBufferBaseNV = _link_function('glBindBufferBaseNV', None, [GLenum, GLuint, GLuint], 'NV_transform_feedback')
# GL/glext.h:10529
glTransformFeedbackVaryingsNV = _link_function('glTransformFeedbackVaryingsNV', None, [GLuint, GLsizei, POINTER(GLint), GLenum], 'NV_transform_feedback')
# GL/glext.h:10530
glActiveVaryingNV = _link_function('glActiveVaryingNV', None, [GLuint, POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:10531
glGetVaryingLocationNV = _link_function('glGetVaryingLocationNV', GLint, [GLuint, POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:10532
glGetActiveVaryingNV = _link_function('glGetActiveVaryingNV', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)], 'NV_transform_feedback')
# GL/glext.h:10533
glGetTransformFeedbackVaryingNV = _link_function('glGetTransformFeedbackVaryingNV', None, [GLuint, GLuint, POINTER(GLint)], 'NV_transform_feedback')
# GL/glext.h:10534
glTransformFeedbackStreamAttribsNV = _link_function('glTransformFeedbackStreamAttribsNV', None, [GLsizei, POINTER(GLint), GLsizei, POINTER(GLint), GLenum], 'NV_transform_feedback')
PFNGLBEGINTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10536
PFNGLENDTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:10537
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint), GLenum) # GL/glext.h:10538
PFNGLBINDBUFFERRANGENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:10539
PFNGLBINDBUFFEROFFSETNVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr) # GL/glext.h:10540
PFNGLBINDBUFFERBASENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:10541
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLint), GLenum) # GL/glext.h:10542
PFNGLACTIVEVARYINGNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLchar)) # GL/glext.h:10543
PFNGLGETVARYINGLOCATIONNVPROC = CFUNCTYPE(GLint, GLuint, POINTER(GLchar)) # GL/glext.h:10544
PFNGLGETACTIVEVARYINGNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:10545
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = CFUNCTYPE(None, GLuint, GLuint, POINTER(GLint)) # GL/glext.h:10546
PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLint), GLsizei, POINTER(GLint), GLenum) # GL/glext.h:10547
# EXT_bindable_uniform (GL/glext.h:10550)
GL_EXT_bindable_uniform = 1 # GL/glext.h:10551
# GL/glext.h:10553
glUniformBufferEXT = _link_function('glUniformBufferEXT', None, [GLuint, GLint, GLuint], 'EXT_bindable_uniform')
# GL/glext.h:10554
glGetUniformBufferSizeEXT = _link_function('glGetUniformBufferSizeEXT', GLint, [GLuint, GLint], 'EXT_bindable_uniform')
# GL/glext.h:10555
glGetUniformOffsetEXT = _link_function('glGetUniformOffsetEXT', GLintptr, [GLuint, GLint], 'EXT_bindable_uniform')
PFNGLUNIFORMBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:10557
PFNGLGETUNIFORMBUFFERSIZEEXTPROC = CFUNCTYPE(GLint, GLuint, GLint) # GL/glext.h:10558
PFNGLGETUNIFORMOFFSETEXTPROC = CFUNCTYPE(GLintptr, GLuint, GLint) # GL/glext.h:10559
# EXT_texture_integer (GL/glext.h:10562)
GL_EXT_texture_integer = 1 # GL/glext.h:10563
# GL/glext.h:10565
glTexParameterIivEXT = _link_function('glTexParameterIivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_texture_integer')
# GL/glext.h:10566
glTexParameterIuivEXT = _link_function('glTexParameterIuivEXT', None, [GLenum, GLenum, POINTER(GLuint)], 'EXT_texture_integer')
# GL/glext.h:10567
glGetTexParameterIivEXT = _link_function('glGetTexParameterIivEXT', None, [GLenum, GLenum, POINTER(GLint)], 'EXT_texture_integer')
# GL/glext.h:10568
glGetTexParameterIuivEXT = _link_function('glGetTexParameterIuivEXT', None, [GLenum, GLenum, POINTER(GLuint)], 'EXT_texture_integer')
# GL/glext.h:10569
glClearColorIiEXT = _link_function('glClearColorIiEXT', None, [GLint, GLint, GLint, GLint], 'EXT_texture_integer')
# GL/glext.h:10570
glClearColorIuiEXT = _link_function('glClearColorIuiEXT', None, [GLuint, GLuint, GLuint, GLuint], 'EXT_texture_integer')
PFNGLTEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10572
PFNGLTEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10573
PFNGLGETTEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10574
PFNGLGETTEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10575
PFNGLCLEARCOLORIIEXTPROC = CFUNCTYPE(None, GLint, GLint, GLint, GLint) # GL/glext.h:10576
PFNGLCLEARCOLORIUIEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10577
# GREMEDY_frame_terminator (GL/glext.h:10580)
GL_GREMEDY_frame_terminator = 1 # GL/glext.h:10581
# GL/glext.h:10583
glFrameTerminatorGREMEDY = _link_function('glFrameTerminatorGREMEDY', None, [], 'GREMEDY_frame_terminator')
PFNGLFRAMETERMINATORGREMEDYPROC = CFUNCTYPE(None) # GL/glext.h:10585
# NV_conditional_render (GL/glext.h:10588)
GL_NV_conditional_render = 1 # GL/glext.h:10589
# GL/glext.h:10591
glBeginConditionalRenderNV = _link_function('glBeginConditionalRenderNV', None, [GLuint, GLenum], 'NV_conditional_render')
# GL/glext.h:10592
glEndConditionalRenderNV = _link_function('glEndConditionalRenderNV', None, [], 'NV_conditional_render')
PFNGLBEGINCONDITIONALRENDERNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:10594
PFNGLENDCONDITIONALRENDERNVPROC = CFUNCTYPE(None) # GL/glext.h:10595
# NV_present_video (GL/glext.h:10598)
GL_NV_present_video = 1 # GL/glext.h:10599
# GL/glext.h:10601
glPresentFrameKeyedNV = _link_function('glPresentFrameKeyedNV', None, [GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint], 'NV_present_video')
# GL/glext.h:10602
glPresentFrameDualFillNV = _link_function('glPresentFrameDualFillNV', None, [GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint], 'NV_present_video')
# GL/glext.h:10603
glGetVideoivNV = _link_function('glGetVideoivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_present_video')
# GL/glext.h:10604
glGetVideouivNV = _link_function('glGetVideouivNV', None, [GLuint, GLenum, POINTER(GLuint)], 'NV_present_video')
# GL/glext.h:10605
glGetVideoi64vNV = _link_function('glGetVideoi64vNV', None, [GLuint, GLenum, POINTER(GLint64EXT)], 'NV_present_video')
# GL/glext.h:10606
glGetVideoui64vNV = _link_function('glGetVideoui64vNV', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'NV_present_video')
PFNGLPRESENTFRAMEKEYEDNVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint) # GL/glext.h:10608
PFNGLPRESENTFRAMEDUALFILLNVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint) # GL/glext.h:10609
PFNGLGETVIDEOIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:10610
PFNGLGETVIDEOUIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint)) # GL/glext.h:10611
PFNGLGETVIDEOI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64EXT)) # GL/glext.h:10612
PFNGLGETVIDEOUI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:10613
# EXT_transform_feedback (GL/glext.h:10616)
GL_EXT_transform_feedback = 1 # GL/glext.h:10617
# GL/glext.h:10619
glBeginTransformFeedbackEXT = _link_function('glBeginTransformFeedbackEXT', None, [GLenum], 'EXT_transform_feedback')
# GL/glext.h:10620
glEndTransformFeedbackEXT = _link_function('glEndTransformFeedbackEXT', None, [], 'EXT_transform_feedback')
# GL/glext.h:10621
glBindBufferRangeEXT = _link_function('glBindBufferRangeEXT', None, [GLenum, GLuint, GLuint, GLintptr, GLsizeiptr], 'EXT_transform_feedback')
# GL/glext.h:10622
glBindBufferOffsetEXT = _link_function('glBindBufferOffsetEXT', None, [GLenum, GLuint, GLuint, GLintptr], 'EXT_transform_feedback')
# GL/glext.h:10623
glBindBufferBaseEXT = _link_function('glBindBufferBaseEXT', None, [GLenum, GLuint, GLuint], 'EXT_transform_feedback')
# GL/glext.h:10624
glTransformFeedbackVaryingsEXT = _link_function('glTransformFeedbackVaryingsEXT', None, [GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum], 'EXT_transform_feedback')
# GL/glext.h:10625
glGetTransformFeedbackVaryingEXT = _link_function('glGetTransformFeedbackVaryingEXT', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)], 'EXT_transform_feedback')
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10627
PFNGLENDTRANSFORMFEEDBACKEXTPROC = CFUNCTYPE(None) # GL/glext.h:10628
PFNGLBINDBUFFERRANGEEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:10629
PFNGLBINDBUFFEROFFSETEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint, GLintptr) # GL/glext.h:10630
PFNGLBINDBUFFERBASEEXTPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint) # GL/glext.h:10631
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(POINTER(GLchar)), GLenum) # GL/glext.h:10632
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLsizei), POINTER(GLenum), POINTER(GLchar)) # GL/glext.h:10633
# EXT_direct_state_access (GL/glext.h:10636)
GL_EXT_direct_state_access = 1 # GL/glext.h:10637
# GL/glext.h:10639
glClientAttribDefaultEXT = _link_function('glClientAttribDefaultEXT', None, [GLbitfield], 'EXT_direct_state_access')
# GL/glext.h:10640
glPushClientAttribDefaultEXT = _link_function('glPushClientAttribDefaultEXT', None, [GLbitfield], 'EXT_direct_state_access')
# GL/glext.h:10641
glMatrixLoadfEXT = _link_function('glMatrixLoadfEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10642
glMatrixLoaddEXT = _link_function('glMatrixLoaddEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10643
glMatrixMultfEXT = _link_function('glMatrixMultfEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10644
glMatrixMultdEXT = _link_function('glMatrixMultdEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10645
glMatrixLoadIdentityEXT = _link_function('glMatrixLoadIdentityEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:10646
glMatrixRotatefEXT = _link_function('glMatrixRotatefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10647
glMatrixRotatedEXT = _link_function('glMatrixRotatedEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10648
glMatrixScalefEXT = _link_function('glMatrixScalefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10649
glMatrixScaledEXT = _link_function('glMatrixScaledEXT', None, [GLenum, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10650
glMatrixTranslatefEXT = _link_function('glMatrixTranslatefEXT', None, [GLenum, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10651
glMatrixTranslatedEXT = _link_function('glMatrixTranslatedEXT', None, [GLenum, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10652
glMatrixFrustumEXT = _link_function('glMatrixFrustumEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10653
glMatrixOrthoEXT = _link_function('glMatrixOrthoEXT', None, [GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10654
glMatrixPopEXT = _link_function('glMatrixPopEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:10655
glMatrixPushEXT = _link_function('glMatrixPushEXT', None, [GLenum], 'EXT_direct_state_access')
# GL/glext.h:10656
glMatrixLoadTransposefEXT = _link_function('glMatrixLoadTransposefEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10657
glMatrixLoadTransposedEXT = _link_function('glMatrixLoadTransposedEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10658
glMatrixMultTransposefEXT = _link_function('glMatrixMultTransposefEXT', None, [GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10659
glMatrixMultTransposedEXT = _link_function('glMatrixMultTransposedEXT', None, [GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10660
glTextureParameterfEXT = _link_function('glTextureParameterfEXT', None, [GLuint, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10661
glTextureParameterfvEXT = _link_function('glTextureParameterfvEXT', None, [GLuint, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10662
glTextureParameteriEXT = _link_function('glTextureParameteriEXT', None, [GLuint, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:10663
glTextureParameterivEXT = _link_function('glTextureParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10664
glTextureImage1DEXT = _link_function('glTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10665
glTextureImage2DEXT = _link_function('glTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10666
glTextureSubImage1DEXT = _link_function('glTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10667
glTextureSubImage2DEXT = _link_function('glTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10668
glCopyTextureImage1DEXT = _link_function('glCopyTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:10669
glCopyTextureImage2DEXT = _link_function('glCopyTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:10670
glCopyTextureSubImage1DEXT = _link_function('glCopyTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10671
glCopyTextureSubImage2DEXT = _link_function('glCopyTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10672
glGetTextureImageEXT = _link_function('glGetTextureImageEXT', None, [GLuint, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10673
glGetTextureParameterfvEXT = _link_function('glGetTextureParameterfvEXT', None, [GLuint, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10674
glGetTextureParameterivEXT = _link_function('glGetTextureParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10675
glGetTextureLevelParameterfvEXT = _link_function('glGetTextureLevelParameterfvEXT', None, [GLuint, GLenum, GLint, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10676
glGetTextureLevelParameterivEXT = _link_function('glGetTextureLevelParameterivEXT', None, [GLuint, GLenum, GLint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10677
glTextureImage3DEXT = _link_function('glTextureImage3DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10678
glTextureSubImage3DEXT = _link_function('glTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10679
glCopyTextureSubImage3DEXT = _link_function('glCopyTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10680
glMultiTexParameterfEXT = _link_function('glMultiTexParameterfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10681
glMultiTexParameterfvEXT = _link_function('glMultiTexParameterfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10682
glMultiTexParameteriEXT = _link_function('glMultiTexParameteriEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:10683
glMultiTexParameterivEXT = _link_function('glMultiTexParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10684
glMultiTexImage1DEXT = _link_function('glMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10685
glMultiTexImage2DEXT = _link_function('glMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10686
glMultiTexSubImage1DEXT = _link_function('glMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10687
glMultiTexSubImage2DEXT = _link_function('glMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10688
glCopyMultiTexImage1DEXT = _link_function('glCopyMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:10689
glCopyMultiTexImage2DEXT = _link_function('glCopyMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint], 'EXT_direct_state_access')
# GL/glext.h:10690
glCopyMultiTexSubImage1DEXT = _link_function('glCopyMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10691
glCopyMultiTexSubImage2DEXT = _link_function('glCopyMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10692
glGetMultiTexImageEXT = _link_function('glGetMultiTexImageEXT', None, [GLenum, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10693
glGetMultiTexParameterfvEXT = _link_function('glGetMultiTexParameterfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10694
glGetMultiTexParameterivEXT = _link_function('glGetMultiTexParameterivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10695
glGetMultiTexLevelParameterfvEXT = _link_function('glGetMultiTexLevelParameterfvEXT', None, [GLenum, GLenum, GLint, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10696
glGetMultiTexLevelParameterivEXT = _link_function('glGetMultiTexLevelParameterivEXT', None, [GLenum, GLenum, GLint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10697
glMultiTexImage3DEXT = _link_function('glMultiTexImage3DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10698
glMultiTexSubImage3DEXT = _link_function('glMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10699
glCopyMultiTexSubImage3DEXT = _link_function('glCopyMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10700
glBindMultiTextureEXT = _link_function('glBindMultiTextureEXT', None, [GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10701
glEnableClientStateIndexedEXT = _link_function('glEnableClientStateIndexedEXT', None, [GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10702
glDisableClientStateIndexedEXT = _link_function('glDisableClientStateIndexedEXT', None, [GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10703
glMultiTexCoordPointerEXT = _link_function('glMultiTexCoordPointerEXT', None, [GLenum, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10704
glMultiTexEnvfEXT = _link_function('glMultiTexEnvfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10705
glMultiTexEnvfvEXT = _link_function('glMultiTexEnvfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10706
glMultiTexEnviEXT = _link_function('glMultiTexEnviEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:10707
glMultiTexEnvivEXT = _link_function('glMultiTexEnvivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10708
glMultiTexGendEXT = _link_function('glMultiTexGendEXT', None, [GLenum, GLenum, GLenum, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10709
glMultiTexGendvEXT = _link_function('glMultiTexGendvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10710
glMultiTexGenfEXT = _link_function('glMultiTexGenfEXT', None, [GLenum, GLenum, GLenum, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10711
glMultiTexGenfvEXT = _link_function('glMultiTexGenfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10712
glMultiTexGeniEXT = _link_function('glMultiTexGeniEXT', None, [GLenum, GLenum, GLenum, GLint], 'EXT_direct_state_access')
# GL/glext.h:10713
glMultiTexGenivEXT = _link_function('glMultiTexGenivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10714
glGetMultiTexEnvfvEXT = _link_function('glGetMultiTexEnvfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10715
glGetMultiTexEnvivEXT = _link_function('glGetMultiTexEnvivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10716
glGetMultiTexGendvEXT = _link_function('glGetMultiTexGendvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10717
glGetMultiTexGenfvEXT = _link_function('glGetMultiTexGenfvEXT', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10718
glGetMultiTexGenivEXT = _link_function('glGetMultiTexGenivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10719
glGetFloatIndexedvEXT = _link_function('glGetFloatIndexedvEXT', None, [GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10720
glGetDoubleIndexedvEXT = _link_function('glGetDoubleIndexedvEXT', None, [GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10721
glGetPointerIndexedvEXT = _link_function('glGetPointerIndexedvEXT', None, [GLenum, GLuint, POINTER(POINTER(GLvoid))], 'EXT_direct_state_access')
# GL/glext.h:10722
glCompressedTextureImage3DEXT = _link_function('glCompressedTextureImage3DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10723
glCompressedTextureImage2DEXT = _link_function('glCompressedTextureImage2DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10724
glCompressedTextureImage1DEXT = _link_function('glCompressedTextureImage1DEXT', None, [GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10725
glCompressedTextureSubImage3DEXT = _link_function('glCompressedTextureSubImage3DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10726
glCompressedTextureSubImage2DEXT = _link_function('glCompressedTextureSubImage2DEXT', None, [GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10727
glCompressedTextureSubImage1DEXT = _link_function('glCompressedTextureSubImage1DEXT', None, [GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10728
glGetCompressedTextureImageEXT = _link_function('glGetCompressedTextureImageEXT', None, [GLuint, GLenum, GLint, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10729
glCompressedMultiTexImage3DEXT = _link_function('glCompressedMultiTexImage3DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10730
glCompressedMultiTexImage2DEXT = _link_function('glCompressedMultiTexImage2DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10731
glCompressedMultiTexImage1DEXT = _link_function('glCompressedMultiTexImage1DEXT', None, [GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10732
glCompressedMultiTexSubImage3DEXT = _link_function('glCompressedMultiTexSubImage3DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10733
glCompressedMultiTexSubImage2DEXT = _link_function('glCompressedMultiTexSubImage2DEXT', None, [GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10734
glCompressedMultiTexSubImage1DEXT = _link_function('glCompressedMultiTexSubImage1DEXT', None, [GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10735
glGetCompressedMultiTexImageEXT = _link_function('glGetCompressedMultiTexImageEXT', None, [GLenum, GLenum, GLint, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10736
glNamedProgramStringEXT = _link_function('glNamedProgramStringEXT', None, [GLuint, GLenum, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10737
glNamedProgramLocalParameter4dEXT = _link_function('glNamedProgramLocalParameter4dEXT', None, [GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10738
glNamedProgramLocalParameter4dvEXT = _link_function('glNamedProgramLocalParameter4dvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10739
glNamedProgramLocalParameter4fEXT = _link_function('glNamedProgramLocalParameter4fEXT', None, [GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10740
glNamedProgramLocalParameter4fvEXT = _link_function('glNamedProgramLocalParameter4fvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10741
glGetNamedProgramLocalParameterdvEXT = _link_function('glGetNamedProgramLocalParameterdvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10742
glGetNamedProgramLocalParameterfvEXT = _link_function('glGetNamedProgramLocalParameterfvEXT', None, [GLuint, GLenum, GLuint, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10743
glGetNamedProgramivEXT = _link_function('glGetNamedProgramivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10744
glGetNamedProgramStringEXT = _link_function('glGetNamedProgramStringEXT', None, [GLuint, GLenum, GLenum, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10745
glNamedProgramLocalParameters4fvEXT = _link_function('glNamedProgramLocalParameters4fvEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10746
glNamedProgramLocalParameterI4iEXT = _link_function('glNamedProgramLocalParameterI4iEXT', None, [GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10747
glNamedProgramLocalParameterI4ivEXT = _link_function('glNamedProgramLocalParameterI4ivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10748
glNamedProgramLocalParametersI4ivEXT = _link_function('glNamedProgramLocalParametersI4ivEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10749
glNamedProgramLocalParameterI4uiEXT = _link_function('glNamedProgramLocalParameterI4uiEXT', None, [GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10750
glNamedProgramLocalParameterI4uivEXT = _link_function('glNamedProgramLocalParameterI4uivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10751
glNamedProgramLocalParametersI4uivEXT = _link_function('glNamedProgramLocalParametersI4uivEXT', None, [GLuint, GLenum, GLuint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10752
glGetNamedProgramLocalParameterIivEXT = _link_function('glGetNamedProgramLocalParameterIivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10753
glGetNamedProgramLocalParameterIuivEXT = _link_function('glGetNamedProgramLocalParameterIuivEXT', None, [GLuint, GLenum, GLuint, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10754
glTextureParameterIivEXT = _link_function('glTextureParameterIivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10755
glTextureParameterIuivEXT = _link_function('glTextureParameterIuivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10756
glGetTextureParameterIivEXT = _link_function('glGetTextureParameterIivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10757
glGetTextureParameterIuivEXT = _link_function('glGetTextureParameterIuivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10758
glMultiTexParameterIivEXT = _link_function('glMultiTexParameterIivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10759
glMultiTexParameterIuivEXT = _link_function('glMultiTexParameterIuivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10760
glGetMultiTexParameterIivEXT = _link_function('glGetMultiTexParameterIivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10761
glGetMultiTexParameterIuivEXT = _link_function('glGetMultiTexParameterIuivEXT', None, [GLenum, GLenum, GLenum, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10762
glProgramUniform1fEXT = _link_function('glProgramUniform1fEXT', None, [GLuint, GLint, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10763
glProgramUniform2fEXT = _link_function('glProgramUniform2fEXT', None, [GLuint, GLint, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10764
glProgramUniform3fEXT = _link_function('glProgramUniform3fEXT', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10765
glProgramUniform4fEXT = _link_function('glProgramUniform4fEXT', None, [GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat], 'EXT_direct_state_access')
# GL/glext.h:10766
glProgramUniform1iEXT = _link_function('glProgramUniform1iEXT', None, [GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10767
glProgramUniform2iEXT = _link_function('glProgramUniform2iEXT', None, [GLuint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10768
glProgramUniform3iEXT = _link_function('glProgramUniform3iEXT', None, [GLuint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10769
glProgramUniform4iEXT = _link_function('glProgramUniform4iEXT', None, [GLuint, GLint, GLint, GLint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10770
glProgramUniform1fvEXT = _link_function('glProgramUniform1fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10771
glProgramUniform2fvEXT = _link_function('glProgramUniform2fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10772
glProgramUniform3fvEXT = _link_function('glProgramUniform3fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10773
glProgramUniform4fvEXT = _link_function('glProgramUniform4fvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10774
glProgramUniform1ivEXT = _link_function('glProgramUniform1ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10775
glProgramUniform2ivEXT = _link_function('glProgramUniform2ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10776
glProgramUniform3ivEXT = _link_function('glProgramUniform3ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10777
glProgramUniform4ivEXT = _link_function('glProgramUniform4ivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10778
glProgramUniformMatrix2fvEXT = _link_function('glProgramUniformMatrix2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10779
glProgramUniformMatrix3fvEXT = _link_function('glProgramUniformMatrix3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10780
glProgramUniformMatrix4fvEXT = _link_function('glProgramUniformMatrix4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10781
glProgramUniformMatrix2x3fvEXT = _link_function('glProgramUniformMatrix2x3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10782
glProgramUniformMatrix3x2fvEXT = _link_function('glProgramUniformMatrix3x2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10783
glProgramUniformMatrix2x4fvEXT = _link_function('glProgramUniformMatrix2x4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10784
glProgramUniformMatrix4x2fvEXT = _link_function('glProgramUniformMatrix4x2fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10785
glProgramUniformMatrix3x4fvEXT = _link_function('glProgramUniformMatrix3x4fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10786
glProgramUniformMatrix4x3fvEXT = _link_function('glProgramUniformMatrix4x3fvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)], 'EXT_direct_state_access')
# GL/glext.h:10787
glProgramUniform1uiEXT = _link_function('glProgramUniform1uiEXT', None, [GLuint, GLint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10788
glProgramUniform2uiEXT = _link_function('glProgramUniform2uiEXT', None, [GLuint, GLint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10789
glProgramUniform3uiEXT = _link_function('glProgramUniform3uiEXT', None, [GLuint, GLint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10790
glProgramUniform4uiEXT = _link_function('glProgramUniform4uiEXT', None, [GLuint, GLint, GLuint, GLuint, GLuint, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10791
glProgramUniform1uivEXT = _link_function('glProgramUniform1uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10792
glProgramUniform2uivEXT = _link_function('glProgramUniform2uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10793
glProgramUniform3uivEXT = _link_function('glProgramUniform3uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10794
glProgramUniform4uivEXT = _link_function('glProgramUniform4uivEXT', None, [GLuint, GLint, GLsizei, POINTER(GLuint)], 'EXT_direct_state_access')
# GL/glext.h:10795
glNamedBufferDataEXT = _link_function('glNamedBufferDataEXT', None, [GLuint, GLsizeiptr, POINTER(GLvoid), GLenum], 'EXT_direct_state_access')
# GL/glext.h:10796
glNamedBufferSubDataEXT = _link_function('glNamedBufferSubDataEXT', None, [GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10797
glMapNamedBufferEXT = _link_function('glMapNamedBufferEXT', POINTER(GLvoid), [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10798
glUnmapNamedBufferEXT = _link_function('glUnmapNamedBufferEXT', GLboolean, [GLuint], 'EXT_direct_state_access')
# GL/glext.h:10799
glMapNamedBufferRangeEXT = _link_function('glMapNamedBufferRangeEXT', POINTER(GLvoid), [GLuint, GLintptr, GLsizeiptr, GLbitfield], 'EXT_direct_state_access')
# GL/glext.h:10800
glFlushMappedNamedBufferRangeEXT = _link_function('glFlushMappedNamedBufferRangeEXT', None, [GLuint, GLintptr, GLsizeiptr], 'EXT_direct_state_access')
# GL/glext.h:10801
glNamedCopyBufferSubDataEXT = _link_function('glNamedCopyBufferSubDataEXT', None, [GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr], 'EXT_direct_state_access')
# GL/glext.h:10802
glGetNamedBufferParameterivEXT = _link_function('glGetNamedBufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10803
glGetNamedBufferPointervEXT = _link_function('glGetNamedBufferPointervEXT', None, [GLuint, GLenum, POINTER(POINTER(GLvoid))], 'EXT_direct_state_access')
# GL/glext.h:10804
glGetNamedBufferSubDataEXT = _link_function('glGetNamedBufferSubDataEXT', None, [GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)], 'EXT_direct_state_access')
# GL/glext.h:10805
glTextureBufferEXT = _link_function('glTextureBufferEXT', None, [GLuint, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10806
glMultiTexBufferEXT = _link_function('glMultiTexBufferEXT', None, [GLenum, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10807
glNamedRenderbufferStorageEXT = _link_function('glNamedRenderbufferStorageEXT', None, [GLuint, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10808
glGetNamedRenderbufferParameterivEXT = _link_function('glGetNamedRenderbufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10809
glCheckNamedFramebufferStatusEXT = _link_function('glCheckNamedFramebufferStatusEXT', GLenum, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10810
glNamedFramebufferTexture1DEXT = _link_function('glNamedFramebufferTexture1DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10811
glNamedFramebufferTexture2DEXT = _link_function('glNamedFramebufferTexture2DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10812
glNamedFramebufferTexture3DEXT = _link_function('glNamedFramebufferTexture3DEXT', None, [GLuint, GLenum, GLenum, GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10813
glNamedFramebufferRenderbufferEXT = _link_function('glNamedFramebufferRenderbufferEXT', None, [GLuint, GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10814
glGetNamedFramebufferAttachmentParameterivEXT = _link_function('glGetNamedFramebufferAttachmentParameterivEXT', None, [GLuint, GLenum, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10815
glGenerateTextureMipmapEXT = _link_function('glGenerateTextureMipmapEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10816
glGenerateMultiTexMipmapEXT = _link_function('glGenerateMultiTexMipmapEXT', None, [GLenum, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10817
glFramebufferDrawBufferEXT = _link_function('glFramebufferDrawBufferEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10818
glFramebufferDrawBuffersEXT = _link_function('glFramebufferDrawBuffersEXT', None, [GLuint, GLsizei, POINTER(GLenum)], 'EXT_direct_state_access')
# GL/glext.h:10819
glFramebufferReadBufferEXT = _link_function('glFramebufferReadBufferEXT', None, [GLuint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10820
glGetFramebufferParameterivEXT = _link_function('glGetFramebufferParameterivEXT', None, [GLuint, GLenum, POINTER(GLint)], 'EXT_direct_state_access')
# GL/glext.h:10821
glNamedRenderbufferStorageMultisampleEXT = _link_function('glNamedRenderbufferStorageMultisampleEXT', None, [GLuint, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10822
glNamedRenderbufferStorageMultisampleCoverageEXT = _link_function('glNamedRenderbufferStorageMultisampleCoverageEXT', None, [GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei], 'EXT_direct_state_access')
# GL/glext.h:10823
glNamedFramebufferTextureEXT = _link_function('glNamedFramebufferTextureEXT', None, [GLuint, GLenum, GLuint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10824
glNamedFramebufferTextureLayerEXT = _link_function('glNamedFramebufferTextureLayerEXT', None, [GLuint, GLenum, GLuint, GLint, GLint], 'EXT_direct_state_access')
# GL/glext.h:10825
glNamedFramebufferTextureFaceEXT = _link_function('glNamedFramebufferTextureFaceEXT', None, [GLuint, GLenum, GLuint, GLint, GLenum], 'EXT_direct_state_access')
# GL/glext.h:10826
glTextureRenderbufferEXT = _link_function('glTextureRenderbufferEXT', None, [GLuint, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10827
glMultiTexRenderbufferEXT = _link_function('glMultiTexRenderbufferEXT', None, [GLenum, GLenum, GLuint], 'EXT_direct_state_access')
# GL/glext.h:10828
glProgramUniform1dEXT = _link_function('glProgramUniform1dEXT', None, [GLuint, GLint, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10829
glProgramUniform2dEXT = _link_function('glProgramUniform2dEXT', None, [GLuint, GLint, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10830
glProgramUniform3dEXT = _link_function('glProgramUniform3dEXT', None, [GLuint, GLint, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10831
glProgramUniform4dEXT = _link_function('glProgramUniform4dEXT', None, [GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_direct_state_access')
# GL/glext.h:10832
glProgramUniform1dvEXT = _link_function('glProgramUniform1dvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10833
glProgramUniform2dvEXT = _link_function('glProgramUniform2dvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10834
glProgramUniform3dvEXT = _link_function('glProgramUniform3dvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10835
glProgramUniform4dvEXT = _link_function('glProgramUniform4dvEXT', None, [GLuint, GLint, GLsizei, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10836
glProgramUniformMatrix2dvEXT = _link_function('glProgramUniformMatrix2dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10837
glProgramUniformMatrix3dvEXT = _link_function('glProgramUniformMatrix3dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10838
glProgramUniformMatrix4dvEXT = _link_function('glProgramUniformMatrix4dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10839
glProgramUniformMatrix2x3dvEXT = _link_function('glProgramUniformMatrix2x3dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10840
glProgramUniformMatrix2x4dvEXT = _link_function('glProgramUniformMatrix2x4dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10841
glProgramUniformMatrix3x2dvEXT = _link_function('glProgramUniformMatrix3x2dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10842
glProgramUniformMatrix3x4dvEXT = _link_function('glProgramUniformMatrix3x4dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10843
glProgramUniformMatrix4x2dvEXT = _link_function('glProgramUniformMatrix4x2dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
# GL/glext.h:10844
glProgramUniformMatrix4x3dvEXT = _link_function('glProgramUniformMatrix4x3dvEXT', None, [GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)], 'EXT_direct_state_access')
PFNGLCLIENTATTRIBDEFAULTEXTPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:10846
PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:10847
PFNGLMATRIXLOADFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:10848
PFNGLMATRIXLOADDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:10849
PFNGLMATRIXMULTFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:10850
PFNGLMATRIXMULTDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:10851
PFNGLMATRIXLOADIDENTITYEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10852
PFNGLMATRIXROTATEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:10853
PFNGLMATRIXROTATEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:10854
PFNGLMATRIXSCALEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:10855
PFNGLMATRIXSCALEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:10856
PFNGLMATRIXTRANSLATEFEXTPROC = CFUNCTYPE(None, GLenum, GLfloat, GLfloat, GLfloat) # GL/glext.h:10857
PFNGLMATRIXTRANSLATEDEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble) # GL/glext.h:10858
PFNGLMATRIXFRUSTUMEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:10859
PFNGLMATRIXORTHOEXTPROC = CFUNCTYPE(None, GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:10860
PFNGLMATRIXPOPEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10861
PFNGLMATRIXPUSHEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:10862
PFNGLMATRIXLOADTRANSPOSEFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:10863
PFNGLMATRIXLOADTRANSPOSEDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:10864
PFNGLMATRIXMULTTRANSPOSEFEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLfloat)) # GL/glext.h:10865
PFNGLMATRIXMULTTRANSPOSEDEXTPROC = CFUNCTYPE(None, GLenum, POINTER(GLdouble)) # GL/glext.h:10866
PFNGLTEXTUREPARAMETERFEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLfloat) # GL/glext.h:10867
PFNGLTEXTUREPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10868
PFNGLTEXTUREPARAMETERIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLint) # GL/glext.h:10869
PFNGLTEXTUREPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10870
PFNGLTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10871
PFNGLTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10872
PFNGLTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10873
PFNGLTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10874
PFNGLCOPYTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:10875
PFNGLCOPYTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:10876
PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:10877
PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:10878
PFNGLGETTEXTUREIMAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10879
PFNGLGETTEXTUREPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10880
PFNGLGETTEXTUREPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10881
PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, POINTER(GLfloat)) # GL/glext.h:10882
PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, POINTER(GLint)) # GL/glext.h:10883
PFNGLTEXTUREIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10884
PFNGLTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10885
PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:10886
PFNGLMULTITEXPARAMETERFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:10887
PFNGLMULTITEXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10888
PFNGLMULTITEXPARAMETERIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:10889
PFNGLMULTITEXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10890
PFNGLMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10891
PFNGLMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10892
PFNGLMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10893
PFNGLMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10894
PFNGLCOPYMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) # GL/glext.h:10895
PFNGLCOPYMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) # GL/glext.h:10896
PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei) # GL/glext.h:10897
PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:10898
PFNGLGETMULTITEXIMAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10899
PFNGLGETMULTITEXPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10900
PFNGLGETMULTITEXPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10901
PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, POINTER(GLfloat)) # GL/glext.h:10902
PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, POINTER(GLint)) # GL/glext.h:10903
PFNGLMULTITEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10904
PFNGLMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10905
PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) # GL/glext.h:10906
PFNGLBINDMULTITEXTUREEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:10907
PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10908
PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:10909
PFNGLMULTITEXCOORDPOINTEREXTPROC = CFUNCTYPE(None, GLenum, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10910
PFNGLMULTITEXENVFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:10911
PFNGLMULTITEXENVFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10912
PFNGLMULTITEXENVIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:10913
PFNGLMULTITEXENVIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10914
PFNGLMULTITEXGENDEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLdouble) # GL/glext.h:10915
PFNGLMULTITEXGENDVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLdouble)) # GL/glext.h:10916
PFNGLMULTITEXGENFEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLfloat) # GL/glext.h:10917
PFNGLMULTITEXGENFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10918
PFNGLMULTITEXGENIEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLint) # GL/glext.h:10919
PFNGLMULTITEXGENIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10920
PFNGLGETMULTITEXENVFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10921
PFNGLGETMULTITEXENVIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10922
PFNGLGETMULTITEXGENDVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLdouble)) # GL/glext.h:10923
PFNGLGETMULTITEXGENFVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:10924
PFNGLGETMULTITEXGENIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10925
PFNGLGETFLOATINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:10926
PFNGLGETDOUBLEINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:10927
PFNGLGETPOINTERINDEXEDVEXTPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(POINTER(GLvoid))) # GL/glext.h:10928
PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10929
PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10930
PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10931
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10932
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10933
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10934
PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:10935
PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10936
PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10937
PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, POINTER(GLvoid)) # GL/glext.h:10938
PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10939
PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10940
PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10941
PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, POINTER(GLvoid)) # GL/glext.h:10942
PFNGLNAMEDPROGRAMSTRINGEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:10943
PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:10944
PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:10945
PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:10946
PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:10947
PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLdouble)) # GL/glext.h:10948
PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:10949
PFNGLGETNAMEDPROGRAMIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10950
PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLvoid)) # GL/glext.h:10951
PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10952
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:10953
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10954
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLint)) # GL/glext.h:10955
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10956
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10957
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLsizei, POINTER(GLuint)) # GL/glext.h:10958
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLint)) # GL/glext.h:10959
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:10960
PFNGLTEXTUREPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10961
PFNGLTEXTUREPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10962
PFNGLGETTEXTUREPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10963
PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10964
PFNGLMULTITEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10965
PFNGLMULTITEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10966
PFNGLGETMULTITEXPARAMETERIIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:10967
PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLuint)) # GL/glext.h:10968
PFNGLPROGRAMUNIFORM1FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat) # GL/glext.h:10969
PFNGLPROGRAMUNIFORM2FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat) # GL/glext.h:10970
PFNGLPROGRAMUNIFORM3FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat) # GL/glext.h:10971
PFNGLPROGRAMUNIFORM4FEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat) # GL/glext.h:10972
PFNGLPROGRAMUNIFORM1IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint) # GL/glext.h:10973
PFNGLPROGRAMUNIFORM2IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint) # GL/glext.h:10974
PFNGLPROGRAMUNIFORM3IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint) # GL/glext.h:10975
PFNGLPROGRAMUNIFORM4IEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLint, GLint, GLint, GLint) # GL/glext.h:10976
PFNGLPROGRAMUNIFORM1FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10977
PFNGLPROGRAMUNIFORM2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10978
PFNGLPROGRAMUNIFORM3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10979
PFNGLPROGRAMUNIFORM4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLfloat)) # GL/glext.h:10980
PFNGLPROGRAMUNIFORM1IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:10981
PFNGLPROGRAMUNIFORM2IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:10982
PFNGLPROGRAMUNIFORM3IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:10983
PFNGLPROGRAMUNIFORM4IVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint)) # GL/glext.h:10984
PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10985
PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10986
PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10987
PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10988
PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10989
PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10990
PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10991
PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10992
PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLfloat)) # GL/glext.h:10993
PFNGLPROGRAMUNIFORM1UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:10994
PFNGLPROGRAMUNIFORM2UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint) # GL/glext.h:10995
PFNGLPROGRAMUNIFORM3UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint) # GL/glext.h:10996
PFNGLPROGRAMUNIFORM4UIEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLuint, GLuint, GLuint, GLuint) # GL/glext.h:10997
PFNGLPROGRAMUNIFORM1UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10998
PFNGLPROGRAMUNIFORM2UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:10999
PFNGLPROGRAMUNIFORM3UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:11000
PFNGLPROGRAMUNIFORM4UIVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint)) # GL/glext.h:11001
PFNGLNAMEDBUFFERDATAEXTPROC = CFUNCTYPE(None, GLuint, GLsizeiptr, POINTER(GLvoid), GLenum) # GL/glext.h:11002
PFNGLNAMEDBUFFERSUBDATAEXTPROC = CFUNCTYPE(None, GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:11003
PFNGLMAPNAMEDBUFFEREXTPROC = CFUNCTYPE(POINTER(GLvoid), GLuint, GLenum) # GL/glext.h:11004
PFNGLUNMAPNAMEDBUFFEREXTPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:11005
PFNGLMAPNAMEDBUFFERRANGEEXTPROC = CFUNCTYPE(POINTER(GLvoid), GLuint, GLintptr, GLsizeiptr, GLbitfield) # GL/glext.h:11006
PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC = CFUNCTYPE(None, GLuint, GLintptr, GLsizeiptr) # GL/glext.h:11007
PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr) # GL/glext.h:11008
PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11009
PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:11010
PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = CFUNCTYPE(None, GLuint, GLintptr, GLsizeiptr, POINTER(GLvoid)) # GL/glext.h:11011
PFNGLTEXTUREBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint) # GL/glext.h:11012
PFNGLMULTITEXBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, GLuint) # GL/glext.h:11013
PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLsizei) # GL/glext.h:11014
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11015
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = CFUNCTYPE(GLenum, GLuint, GLenum) # GL/glext.h:11016
PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint) # GL/glext.h:11017
PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint) # GL/glext.h:11018
PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint, GLint, GLint) # GL/glext.h:11019
PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLuint) # GL/glext.h:11020
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:11021
PFNGLGENERATETEXTUREMIPMAPEXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11022
PFNGLGENERATEMULTITEXMIPMAPEXTPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:11023
PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11024
PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLenum)) # GL/glext.h:11025
PFNGLFRAMEBUFFERREADBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11026
PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11027
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:11028
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC = CFUNCTYPE(None, GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei) # GL/glext.h:11029
PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint) # GL/glext.h:11030
PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLint) # GL/glext.h:11031
PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint, GLint, GLenum) # GL/glext.h:11032
PFNGLTEXTURERENDERBUFFEREXTPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint) # GL/glext.h:11033
PFNGLMULTITEXRENDERBUFFEREXTPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint) # GL/glext.h:11034
PFNGLPROGRAMUNIFORM1DEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble) # GL/glext.h:11035
PFNGLPROGRAMUNIFORM2DEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble) # GL/glext.h:11036
PFNGLPROGRAMUNIFORM3DEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble, GLdouble) # GL/glext.h:11037
PFNGLPROGRAMUNIFORM4DEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:11038
PFNGLPROGRAMUNIFORM1DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:11039
PFNGLPROGRAMUNIFORM2DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:11040
PFNGLPROGRAMUNIFORM3DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:11041
PFNGLPROGRAMUNIFORM4DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLdouble)) # GL/glext.h:11042
PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11043
PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11044
PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11045
PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11046
PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11047
PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11048
PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11049
PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11050
PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, GLboolean, POINTER(GLdouble)) # GL/glext.h:11051
# EXT_vertex_array_bgra (GL/glext.h:11054)
GL_EXT_vertex_array_bgra = 1 # GL/glext.h:11055
# EXT_texture_swizzle (GL/glext.h:11058)
GL_EXT_texture_swizzle = 1 # GL/glext.h:11059
# NV_explicit_multisample (GL/glext.h:11062)
GL_NV_explicit_multisample = 1 # GL/glext.h:11063
# GL/glext.h:11065
glGetMultisamplefvNV = _link_function('glGetMultisamplefvNV', None, [GLenum, GLuint, POINTER(GLfloat)], 'NV_explicit_multisample')
# GL/glext.h:11066
glSampleMaskIndexedNV = _link_function('glSampleMaskIndexedNV', None, [GLuint, GLbitfield], 'NV_explicit_multisample')
# GL/glext.h:11067
glTexRenderbufferNV = _link_function('glTexRenderbufferNV', None, [GLenum, GLuint], 'NV_explicit_multisample')
PFNGLGETMULTISAMPLEFVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:11069
PFNGLSAMPLEMASKINDEXEDNVPROC = CFUNCTYPE(None, GLuint, GLbitfield) # GL/glext.h:11070
PFNGLTEXRENDERBUFFERNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:11071
# NV_transform_feedback2 (GL/glext.h:11074)
GL_NV_transform_feedback2 = 1 # GL/glext.h:11075
# GL/glext.h:11077
glBindTransformFeedbackNV = _link_function('glBindTransformFeedbackNV', None, [GLenum, GLuint], 'NV_transform_feedback2')
# GL/glext.h:11078
glDeleteTransformFeedbacksNV = _link_function('glDeleteTransformFeedbacksNV', None, [GLsizei, POINTER(GLuint)], 'NV_transform_feedback2')
# GL/glext.h:11079
glGenTransformFeedbacksNV = _link_function('glGenTransformFeedbacksNV', None, [GLsizei, POINTER(GLuint)], 'NV_transform_feedback2')
# GL/glext.h:11080
glIsTransformFeedbackNV = _link_function('glIsTransformFeedbackNV', GLboolean, [GLuint], 'NV_transform_feedback2')
# GL/glext.h:11081
glPauseTransformFeedbackNV = _link_function('glPauseTransformFeedbackNV', None, [], 'NV_transform_feedback2')
# GL/glext.h:11082
glResumeTransformFeedbackNV = _link_function('glResumeTransformFeedbackNV', None, [], 'NV_transform_feedback2')
# GL/glext.h:11083
glDrawTransformFeedbackNV = _link_function('glDrawTransformFeedbackNV', None, [GLenum, GLuint], 'NV_transform_feedback2')
PFNGLBINDTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:11085
PFNGLDELETETRANSFORMFEEDBACKSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:11086
PFNGLGENTRANSFORMFEEDBACKSNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:11087
PFNGLISTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:11088
PFNGLPAUSETRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:11089
PFNGLRESUMETRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None) # GL/glext.h:11090
PFNGLDRAWTRANSFORMFEEDBACKNVPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:11091
# ATI_meminfo (GL/glext.h:11094)
GL_ATI_meminfo = 1 # GL/glext.h:11095
# AMD_performance_monitor (GL/glext.h:11098)
GL_AMD_performance_monitor = 1 # GL/glext.h:11099
# GL/glext.h:11101
glGetPerfMonitorGroupsAMD = _link_function('glGetPerfMonitorGroupsAMD', None, [POINTER(GLint), GLsizei, POINTER(GLuint)], 'AMD_performance_monitor')
# GL/glext.h:11102
glGetPerfMonitorCountersAMD = _link_function('glGetPerfMonitorCountersAMD', None, [GLuint, POINTER(GLint), POINTER(GLint), GLsizei, POINTER(GLuint)], 'AMD_performance_monitor')
# GL/glext.h:11103
glGetPerfMonitorGroupStringAMD = _link_function('glGetPerfMonitorGroupStringAMD', None, [GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'AMD_performance_monitor')
# GL/glext.h:11104
glGetPerfMonitorCounterStringAMD = _link_function('glGetPerfMonitorCounterStringAMD', None, [GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)], 'AMD_performance_monitor')
# GL/glext.h:11105
glGetPerfMonitorCounterInfoAMD = _link_function('glGetPerfMonitorCounterInfoAMD', None, [GLuint, GLuint, GLenum, POINTER(GLvoid)], 'AMD_performance_monitor')
# GL/glext.h:11106
glGenPerfMonitorsAMD = _link_function('glGenPerfMonitorsAMD', None, [GLsizei, POINTER(GLuint)], 'AMD_performance_monitor')
# GL/glext.h:11107
glDeletePerfMonitorsAMD = _link_function('glDeletePerfMonitorsAMD', None, [GLsizei, POINTER(GLuint)], 'AMD_performance_monitor')
# GL/glext.h:11108
glSelectPerfMonitorCountersAMD = _link_function('glSelectPerfMonitorCountersAMD', None, [GLuint, GLboolean, GLuint, GLint, POINTER(GLuint)], 'AMD_performance_monitor')
# GL/glext.h:11109
glBeginPerfMonitorAMD = _link_function('glBeginPerfMonitorAMD', None, [GLuint], 'AMD_performance_monitor')
# GL/glext.h:11110
glEndPerfMonitorAMD = _link_function('glEndPerfMonitorAMD', None, [GLuint], 'AMD_performance_monitor')
# GL/glext.h:11111
glGetPerfMonitorCounterDataAMD = _link_function('glGetPerfMonitorCounterDataAMD', None, [GLuint, GLenum, GLsizei, POINTER(GLuint), POINTER(GLint)], 'AMD_performance_monitor')
PFNGLGETPERFMONITORGROUPSAMDPROC = CFUNCTYPE(None, POINTER(GLint), GLsizei, POINTER(GLuint)) # GL/glext.h:11113
PFNGLGETPERFMONITORCOUNTERSAMDPROC = CFUNCTYPE(None, GLuint, POINTER(GLint), POINTER(GLint), GLsizei, POINTER(GLuint)) # GL/glext.h:11114
PFNGLGETPERFMONITORGROUPSTRINGAMDPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:11115
PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC = CFUNCTYPE(None, GLuint, GLuint, GLsizei, POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:11116
PFNGLGETPERFMONITORCOUNTERINFOAMDPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLvoid)) # GL/glext.h:11117
PFNGLGENPERFMONITORSAMDPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:11118
PFNGLDELETEPERFMONITORSAMDPROC = CFUNCTYPE(None, GLsizei, POINTER(GLuint)) # GL/glext.h:11119
PFNGLSELECTPERFMONITORCOUNTERSAMDPROC = CFUNCTYPE(None, GLuint, GLboolean, GLuint, GLint, POINTER(GLuint)) # GL/glext.h:11120
PFNGLBEGINPERFMONITORAMDPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11121
PFNGLENDPERFMONITORAMDPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11122
PFNGLGETPERFMONITORCOUNTERDATAAMDPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, POINTER(GLuint), POINTER(GLint)) # GL/glext.h:11123
# AMD_texture_texture4 (GL/glext.h:11126)
GL_AMD_texture_texture4 = 1 # GL/glext.h:11127
# AMD_vertex_shader_tesselator (GL/glext.h:11130)
GL_AMD_vertex_shader_tesselator = 1 # GL/glext.h:11131
# GL/glext.h:11133
glTessellationFactorAMD = _link_function('glTessellationFactorAMD', None, [GLfloat], 'AMD_vertex_shader_tesselator')
# GL/glext.h:11134
glTessellationModeAMD = _link_function('glTessellationModeAMD', None, [GLenum], 'AMD_vertex_shader_tesselator')
PFNGLTESSELLATIONFACTORAMDPROC = CFUNCTYPE(None, GLfloat) # GL/glext.h:11136
PFNGLTESSELLATIONMODEAMDPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:11137
# EXT_provoking_vertex (GL/glext.h:11140)
GL_EXT_provoking_vertex = 1 # GL/glext.h:11141
# GL/glext.h:11143
glProvokingVertexEXT = _link_function('glProvokingVertexEXT', None, [GLenum], 'EXT_provoking_vertex')
PFNGLPROVOKINGVERTEXEXTPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:11145
# EXT_texture_snorm (GL/glext.h:11148)
GL_EXT_texture_snorm = 1 # GL/glext.h:11149
# AMD_draw_buffers_blend (GL/glext.h:11152)
GL_AMD_draw_buffers_blend = 1 # GL/glext.h:11153
# GL/glext.h:11155
glBlendFuncIndexedAMD = _link_function('glBlendFuncIndexedAMD', None, [GLuint, GLenum, GLenum], 'AMD_draw_buffers_blend')
# GL/glext.h:11156
glBlendFuncSeparateIndexedAMD = _link_function('glBlendFuncSeparateIndexedAMD', None, [GLuint, GLenum, GLenum, GLenum, GLenum], 'AMD_draw_buffers_blend')
# GL/glext.h:11157
glBlendEquationIndexedAMD = _link_function('glBlendEquationIndexedAMD', None, [GLuint, GLenum], 'AMD_draw_buffers_blend')
# GL/glext.h:11158
glBlendEquationSeparateIndexedAMD = _link_function('glBlendEquationSeparateIndexedAMD', None, [GLuint, GLenum, GLenum], 'AMD_draw_buffers_blend')
PFNGLBLENDFUNCINDEXEDAMDPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:11160
PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum, GLenum, GLenum) # GL/glext.h:11161
PFNGLBLENDEQUATIONINDEXEDAMDPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11162
PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC = CFUNCTYPE(None, GLuint, GLenum, GLenum) # GL/glext.h:11163
# APPLE_texture_range (GL/glext.h:11166)
GL_APPLE_texture_range = 1 # GL/glext.h:11167
# GL/glext.h:11169
glTextureRangeAPPLE = _link_function('glTextureRangeAPPLE', None, [GLenum, GLsizei, POINTER(GLvoid)], 'APPLE_texture_range')
# GL/glext.h:11170
glGetTexParameterPointervAPPLE = _link_function('glGetTexParameterPointervAPPLE', None, [GLenum, GLenum, POINTER(POINTER(GLvoid))], 'APPLE_texture_range')
PFNGLTEXTURERANGEAPPLEPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:11172
PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(POINTER(GLvoid))) # GL/glext.h:11173
# APPLE_float_pixels (GL/glext.h:11176)
GL_APPLE_float_pixels = 1 # GL/glext.h:11177
# APPLE_vertex_program_evaluators (GL/glext.h:11180)
GL_APPLE_vertex_program_evaluators = 1 # GL/glext.h:11181
# GL/glext.h:11183
glEnableVertexAttribAPPLE = _link_function('glEnableVertexAttribAPPLE', None, [GLuint, GLenum], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11184
glDisableVertexAttribAPPLE = _link_function('glDisableVertexAttribAPPLE', None, [GLuint, GLenum], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11185
glIsVertexAttribEnabledAPPLE = _link_function('glIsVertexAttribEnabledAPPLE', GLboolean, [GLuint, GLenum], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11186
glMapVertexAttrib1dAPPLE = _link_function('glMapVertexAttrib1dAPPLE', None, [GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11187
glMapVertexAttrib1fAPPLE = _link_function('glMapVertexAttrib1fAPPLE', None, [GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11188
glMapVertexAttrib2dAPPLE = _link_function('glMapVertexAttrib2dAPPLE', None, [GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)], 'APPLE_vertex_program_evaluators')
# GL/glext.h:11189
glMapVertexAttrib2fAPPLE = _link_function('glMapVertexAttrib2fAPPLE', None, [GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)], 'APPLE_vertex_program_evaluators')
PFNGLENABLEVERTEXATTRIBAPPLEPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11191
PFNGLDISABLEVERTEXATTRIBAPPLEPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11192
PFNGLISVERTEXATTRIBENABLEDAPPLEPROC = CFUNCTYPE(GLboolean, GLuint, GLenum) # GL/glext.h:11193
PFNGLMAPVERTEXATTRIB1DAPPLEPROC = CFUNCTYPE(None, GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)) # GL/glext.h:11194
PFNGLMAPVERTEXATTRIB1FAPPLEPROC = CFUNCTYPE(None, GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)) # GL/glext.h:11195
PFNGLMAPVERTEXATTRIB2DAPPLEPROC = CFUNCTYPE(None, GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, POINTER(GLdouble)) # GL/glext.h:11196
PFNGLMAPVERTEXATTRIB2FAPPLEPROC = CFUNCTYPE(None, GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, POINTER(GLfloat)) # GL/glext.h:11197
# APPLE_aux_depth_stencil (GL/glext.h:11200)
GL_APPLE_aux_depth_stencil = 1 # GL/glext.h:11201
# APPLE_object_purgeable (GL/glext.h:11204)
GL_APPLE_object_purgeable = 1 # GL/glext.h:11205
# GL/glext.h:11207
glObjectPurgeableAPPLE = _link_function('glObjectPurgeableAPPLE', GLenum, [GLenum, GLuint, GLenum], 'APPLE_object_purgeable')
# GL/glext.h:11208
glObjectUnpurgeableAPPLE = _link_function('glObjectUnpurgeableAPPLE', GLenum, [GLenum, GLuint, GLenum], 'APPLE_object_purgeable')
# GL/glext.h:11209
glGetObjectParameterivAPPLE = _link_function('glGetObjectParameterivAPPLE', None, [GLenum, GLuint, GLenum, POINTER(GLint)], 'APPLE_object_purgeable')
PFNGLOBJECTPURGEABLEAPPLEPROC = CFUNCTYPE(GLenum, GLenum, GLuint, GLenum) # GL/glext.h:11211
PFNGLOBJECTUNPURGEABLEAPPLEPROC = CFUNCTYPE(GLenum, GLenum, GLuint, GLenum) # GL/glext.h:11212
PFNGLGETOBJECTPARAMETERIVAPPLEPROC = CFUNCTYPE(None, GLenum, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11213
# APPLE_row_bytes (GL/glext.h:11216)
GL_APPLE_row_bytes = 1 # GL/glext.h:11217
# APPLE_rgb_422 (GL/glext.h:11220)
GL_APPLE_rgb_422 = 1 # GL/glext.h:11221
# NV_video_capture (GL/glext.h:11224)
GL_NV_video_capture = 1 # GL/glext.h:11225
# GL/glext.h:11227
glBeginVideoCaptureNV = _link_function('glBeginVideoCaptureNV', None, [GLuint], 'NV_video_capture')
# GL/glext.h:11228
glBindVideoCaptureStreamBufferNV = _link_function('glBindVideoCaptureStreamBufferNV', None, [GLuint, GLuint, GLenum, GLintptrARB], 'NV_video_capture')
# GL/glext.h:11229
glBindVideoCaptureStreamTextureNV = _link_function('glBindVideoCaptureStreamTextureNV', None, [GLuint, GLuint, GLenum, GLenum, GLuint], 'NV_video_capture')
# GL/glext.h:11230
glEndVideoCaptureNV = _link_function('glEndVideoCaptureNV', None, [GLuint], 'NV_video_capture')
# GL/glext.h:11231
glGetVideoCaptureivNV = _link_function('glGetVideoCaptureivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_video_capture')
# GL/glext.h:11232
glGetVideoCaptureStreamivNV = _link_function('glGetVideoCaptureStreamivNV', None, [GLuint, GLuint, GLenum, POINTER(GLint)], 'NV_video_capture')
# GL/glext.h:11233
glGetVideoCaptureStreamfvNV = _link_function('glGetVideoCaptureStreamfvNV', None, [GLuint, GLuint, GLenum, POINTER(GLfloat)], 'NV_video_capture')
# GL/glext.h:11234
glGetVideoCaptureStreamdvNV = _link_function('glGetVideoCaptureStreamdvNV', None, [GLuint, GLuint, GLenum, POINTER(GLdouble)], 'NV_video_capture')
# GL/glext.h:11235
glVideoCaptureNV = _link_function('glVideoCaptureNV', GLenum, [GLuint, POINTER(GLuint), POINTER(GLuint64EXT)], 'NV_video_capture')
# GL/glext.h:11236
glVideoCaptureStreamParameterivNV = _link_function('glVideoCaptureStreamParameterivNV', None, [GLuint, GLuint, GLenum, POINTER(GLint)], 'NV_video_capture')
# GL/glext.h:11237
glVideoCaptureStreamParameterfvNV = _link_function('glVideoCaptureStreamParameterfvNV', None, [GLuint, GLuint, GLenum, POINTER(GLfloat)], 'NV_video_capture')
# GL/glext.h:11238
glVideoCaptureStreamParameterdvNV = _link_function('glVideoCaptureStreamParameterdvNV', None, [GLuint, GLuint, GLenum, POINTER(GLdouble)], 'NV_video_capture')
PFNGLBEGINVIDEOCAPTURENVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11240
PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLintptrARB) # GL/glext.h:11241
PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, GLenum, GLuint) # GL/glext.h:11242
PFNGLENDVIDEOCAPTURENVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11243
PFNGLGETVIDEOCAPTUREIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11244
PFNGLGETVIDEOCAPTURESTREAMIVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11245
PFNGLGETVIDEOCAPTURESTREAMFVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11246
PFNGLGETVIDEOCAPTURESTREAMDVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:11247
PFNGLVIDEOCAPTURENVPROC = CFUNCTYPE(GLenum, GLuint, POINTER(GLuint), POINTER(GLuint64EXT)) # GL/glext.h:11248
PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11249
PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11250
PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:11251
# NV_copy_image (GL/glext.h:11254)
GL_NV_copy_image = 1 # GL/glext.h:11255
# GL/glext.h:11257
glCopyImageSubDataNV = _link_function('glCopyImageSubDataNV', None, [GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei], 'NV_copy_image')
PFNGLCOPYIMAGESUBDATANVPROC = CFUNCTYPE(None, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) # GL/glext.h:11259
# EXT_separate_shader_objects (GL/glext.h:11262)
GL_EXT_separate_shader_objects = 1 # GL/glext.h:11263
# GL/glext.h:11265
glUseShaderProgramEXT = _link_function('glUseShaderProgramEXT', None, [GLenum, GLuint], 'EXT_separate_shader_objects')
# GL/glext.h:11266
glActiveProgramEXT = _link_function('glActiveProgramEXT', None, [GLuint], 'EXT_separate_shader_objects')
# GL/glext.h:11267
glCreateShaderProgramEXT = _link_function('glCreateShaderProgramEXT', GLuint, [GLenum, POINTER(GLchar)], 'EXT_separate_shader_objects')
PFNGLUSESHADERPROGRAMEXTPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:11269
PFNGLACTIVEPROGRAMEXTPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11270
PFNGLCREATESHADERPROGRAMEXTPROC = CFUNCTYPE(GLuint, GLenum, POINTER(GLchar)) # GL/glext.h:11271
# NV_parameter_buffer_object2 (GL/glext.h:11274)
GL_NV_parameter_buffer_object2 = 1 # GL/glext.h:11275
# NV_shader_buffer_load (GL/glext.h:11278)
GL_NV_shader_buffer_load = 1 # GL/glext.h:11279
# GL/glext.h:11281
glMakeBufferResidentNV = _link_function('glMakeBufferResidentNV', None, [GLenum, GLenum], 'NV_shader_buffer_load')
# GL/glext.h:11282
glMakeBufferNonResidentNV = _link_function('glMakeBufferNonResidentNV', None, [GLenum], 'NV_shader_buffer_load')
# GL/glext.h:11283
glIsBufferResidentNV = _link_function('glIsBufferResidentNV', GLboolean, [GLenum], 'NV_shader_buffer_load')
# GL/glext.h:11284
glMakeNamedBufferResidentNV = _link_function('glMakeNamedBufferResidentNV', None, [GLuint, GLenum], 'NV_shader_buffer_load')
# GL/glext.h:11285
glMakeNamedBufferNonResidentNV = _link_function('glMakeNamedBufferNonResidentNV', None, [GLuint], 'NV_shader_buffer_load')
# GL/glext.h:11286
glIsNamedBufferResidentNV = _link_function('glIsNamedBufferResidentNV', GLboolean, [GLuint], 'NV_shader_buffer_load')
# GL/glext.h:11287
glGetBufferParameterui64vNV = _link_function('glGetBufferParameterui64vNV', None, [GLenum, GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:11288
glGetNamedBufferParameterui64vNV = _link_function('glGetNamedBufferParameterui64vNV', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:11289
glGetIntegerui64vNV = _link_function('glGetIntegerui64vNV', None, [GLenum, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:11290
glUniformui64NV = _link_function('glUniformui64NV', None, [GLint, GLuint64EXT], 'NV_shader_buffer_load')
# GL/glext.h:11291
glUniformui64vNV = _link_function('glUniformui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:11292
glGetUniformui64vNV = _link_function('glGetUniformui64vNV', None, [GLuint, GLint, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
# GL/glext.h:11293
glProgramUniformui64NV = _link_function('glProgramUniformui64NV', None, [GLuint, GLint, GLuint64EXT], 'NV_shader_buffer_load')
# GL/glext.h:11294
glProgramUniformui64vNV = _link_function('glProgramUniformui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_shader_buffer_load')
PFNGLMAKEBUFFERRESIDENTNVPROC = CFUNCTYPE(None, GLenum, GLenum) # GL/glext.h:11296
PFNGLMAKEBUFFERNONRESIDENTNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:11297
PFNGLISBUFFERRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLenum) # GL/glext.h:11298
PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11299
PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = CFUNCTYPE(None, GLuint) # GL/glext.h:11300
PFNGLISNAMEDBUFFERRESIDENTNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:11301
PFNGLGETBUFFERPARAMETERUI64VNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:11302
PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:11303
PFNGLGETINTEGERUI64VNVPROC = CFUNCTYPE(None, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:11304
PFNGLUNIFORMUI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT) # GL/glext.h:11305
PFNGLUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11306
PFNGLGETUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLuint64EXT)) # GL/glext.h:11307
PFNGLPROGRAMUNIFORMUI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT) # GL/glext.h:11308
PFNGLPROGRAMUNIFORMUI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11309
# NV_vertex_buffer_unified_memory (GL/glext.h:11312)
GL_NV_vertex_buffer_unified_memory = 1 # GL/glext.h:11313
# GL/glext.h:11315
glBufferAddressRangeNV = _link_function('glBufferAddressRangeNV', None, [GLenum, GLuint, GLuint64EXT, GLsizeiptr], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11316
glVertexFormatNV = _link_function('glVertexFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11317
glNormalFormatNV = _link_function('glNormalFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11318
glColorFormatNV = _link_function('glColorFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11319
glIndexFormatNV = _link_function('glIndexFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11320
glTexCoordFormatNV = _link_function('glTexCoordFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11321
glEdgeFlagFormatNV = _link_function('glEdgeFlagFormatNV', None, [GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11322
glSecondaryColorFormatNV = _link_function('glSecondaryColorFormatNV', None, [GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11323
glFogCoordFormatNV = _link_function('glFogCoordFormatNV', None, [GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11324
glVertexAttribFormatNV = _link_function('glVertexAttribFormatNV', None, [GLuint, GLint, GLenum, GLboolean, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11325
glVertexAttribIFormatNV = _link_function('glVertexAttribIFormatNV', None, [GLuint, GLint, GLenum, GLsizei], 'NV_vertex_buffer_unified_memory')
# GL/glext.h:11326
glGetIntegerui64i_vNV = _link_function('glGetIntegerui64i_vNV', None, [GLenum, GLuint, POINTER(GLuint64EXT)], 'NV_vertex_buffer_unified_memory')
PFNGLBUFFERADDRESSRANGENVPROC = CFUNCTYPE(None, GLenum, GLuint, GLuint64EXT, GLsizeiptr) # GL/glext.h:11328
PFNGLVERTEXFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:11329
PFNGLNORMALFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:11330
PFNGLCOLORFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:11331
PFNGLINDEXFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:11332
PFNGLTEXCOORDFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:11333
PFNGLEDGEFLAGFORMATNVPROC = CFUNCTYPE(None, GLsizei) # GL/glext.h:11334
PFNGLSECONDARYCOLORFORMATNVPROC = CFUNCTYPE(None, GLint, GLenum, GLsizei) # GL/glext.h:11335
PFNGLFOGCOORDFORMATNVPROC = CFUNCTYPE(None, GLenum, GLsizei) # GL/glext.h:11336
PFNGLVERTEXATTRIBFORMATNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLboolean, GLsizei) # GL/glext.h:11337
PFNGLVERTEXATTRIBIFORMATNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei) # GL/glext.h:11338
PFNGLGETINTEGERUI64I_VNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:11339
# NV_texture_barrier (GL/glext.h:11342)
GL_NV_texture_barrier = 1 # GL/glext.h:11343
# GL/glext.h:11345
glTextureBarrierNV = _link_function('glTextureBarrierNV', None, [], 'NV_texture_barrier')
PFNGLTEXTUREBARRIERNVPROC = CFUNCTYPE(None) # GL/glext.h:11347
# AMD_shader_stencil_export (GL/glext.h:11350)
GL_AMD_shader_stencil_export = 1 # GL/glext.h:11351
# AMD_seamless_cubemap_per_texture (GL/glext.h:11354)
GL_AMD_seamless_cubemap_per_texture = 1 # GL/glext.h:11355
# AMD_conservative_depth (GL/glext.h:11358)
GL_AMD_conservative_depth = 1 # GL/glext.h:11359
# EXT_shader_image_load_store (GL/glext.h:11362)
GL_EXT_shader_image_load_store = 1 # GL/glext.h:11363
# GL/glext.h:11365
glBindImageTextureEXT = _link_function('glBindImageTextureEXT', None, [GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint], 'EXT_shader_image_load_store')
# GL/glext.h:11366
glMemoryBarrierEXT = _link_function('glMemoryBarrierEXT', None, [GLbitfield], 'EXT_shader_image_load_store')
PFNGLBINDIMAGETEXTUREEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint) # GL/glext.h:11368
PFNGLMEMORYBARRIEREXTPROC = CFUNCTYPE(None, GLbitfield) # GL/glext.h:11369
# EXT_vertex_attrib_64bit (GL/glext.h:11372)
GL_EXT_vertex_attrib_64bit = 1 # GL/glext.h:11373
# GL/glext.h:11375
glVertexAttribL1dEXT = _link_function('glVertexAttribL1dEXT', None, [GLuint, GLdouble], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11376
glVertexAttribL2dEXT = _link_function('glVertexAttribL2dEXT', None, [GLuint, GLdouble, GLdouble], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11377
glVertexAttribL3dEXT = _link_function('glVertexAttribL3dEXT', None, [GLuint, GLdouble, GLdouble, GLdouble], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11378
glVertexAttribL4dEXT = _link_function('glVertexAttribL4dEXT', None, [GLuint, GLdouble, GLdouble, GLdouble, GLdouble], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11379
glVertexAttribL1dvEXT = _link_function('glVertexAttribL1dvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11380
glVertexAttribL2dvEXT = _link_function('glVertexAttribL2dvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11381
glVertexAttribL3dvEXT = _link_function('glVertexAttribL3dvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11382
glVertexAttribL4dvEXT = _link_function('glVertexAttribL4dvEXT', None, [GLuint, POINTER(GLdouble)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11383
glVertexAttribLPointerEXT = _link_function('glVertexAttribLPointerEXT', None, [GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11384
glGetVertexAttribLdvEXT = _link_function('glGetVertexAttribLdvEXT', None, [GLuint, GLenum, POINTER(GLdouble)], 'EXT_vertex_attrib_64bit')
# GL/glext.h:11385
glVertexArrayVertexAttribLOffsetEXT = _link_function('glVertexArrayVertexAttribLOffsetEXT', None, [GLuint, GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr], 'EXT_vertex_attrib_64bit')
PFNGLVERTEXATTRIBL1DEXTPROC = CFUNCTYPE(None, GLuint, GLdouble) # GL/glext.h:11387
PFNGLVERTEXATTRIBL2DEXTPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble) # GL/glext.h:11388
PFNGLVERTEXATTRIBL3DEXTPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble) # GL/glext.h:11389
PFNGLVERTEXATTRIBL4DEXTPROC = CFUNCTYPE(None, GLuint, GLdouble, GLdouble, GLdouble, GLdouble) # GL/glext.h:11390
PFNGLVERTEXATTRIBL1DVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:11391
PFNGLVERTEXATTRIBL2DVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:11392
PFNGLVERTEXATTRIBL3DVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:11393
PFNGLVERTEXATTRIBL4DVEXTPROC = CFUNCTYPE(None, GLuint, POINTER(GLdouble)) # GL/glext.h:11394
PFNGLVERTEXATTRIBLPOINTEREXTPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:11395
PFNGLGETVERTEXATTRIBLDVEXTPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLdouble)) # GL/glext.h:11396
PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLint, GLenum, GLsizei, GLintptr) # GL/glext.h:11397
# NV_gpu_program5 (GL/glext.h:11400)
GL_NV_gpu_program5 = 1 # GL/glext.h:11401
# GL/glext.h:11403
glProgramSubroutineParametersuivNV = _link_function('glProgramSubroutineParametersuivNV', None, [GLenum, GLsizei, POINTER(GLuint)], 'NV_gpu_program5')
# GL/glext.h:11404
glGetProgramSubroutineParameteruivNV = _link_function('glGetProgramSubroutineParameteruivNV', None, [GLenum, GLuint, POINTER(GLuint)], 'NV_gpu_program5')
PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC = CFUNCTYPE(None, GLenum, GLsizei, POINTER(GLuint)) # GL/glext.h:11406
PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:11407
# NV_gpu_shader5 (GL/glext.h:11410)
GL_NV_gpu_shader5 = 1 # GL/glext.h:11411
# GL/glext.h:11413
glUniform1i64NV = _link_function('glUniform1i64NV', None, [GLint, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11414
glUniform2i64NV = _link_function('glUniform2i64NV', None, [GLint, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11415
glUniform3i64NV = _link_function('glUniform3i64NV', None, [GLint, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11416
glUniform4i64NV = _link_function('glUniform4i64NV', None, [GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11417
glUniform1i64vNV = _link_function('glUniform1i64vNV', None, [GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11418
glUniform2i64vNV = _link_function('glUniform2i64vNV', None, [GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11419
glUniform3i64vNV = _link_function('glUniform3i64vNV', None, [GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11420
glUniform4i64vNV = _link_function('glUniform4i64vNV', None, [GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11421
glUniform1ui64NV = _link_function('glUniform1ui64NV', None, [GLint, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11422
glUniform2ui64NV = _link_function('glUniform2ui64NV', None, [GLint, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11423
glUniform3ui64NV = _link_function('glUniform3ui64NV', None, [GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11424
glUniform4ui64NV = _link_function('glUniform4ui64NV', None, [GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11425
glUniform1ui64vNV = _link_function('glUniform1ui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11426
glUniform2ui64vNV = _link_function('glUniform2ui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11427
glUniform3ui64vNV = _link_function('glUniform3ui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11428
glUniform4ui64vNV = _link_function('glUniform4ui64vNV', None, [GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11429
glGetUniformi64vNV = _link_function('glGetUniformi64vNV', None, [GLuint, GLint, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11430
glProgramUniform1i64NV = _link_function('glProgramUniform1i64NV', None, [GLuint, GLint, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11431
glProgramUniform2i64NV = _link_function('glProgramUniform2i64NV', None, [GLuint, GLint, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11432
glProgramUniform3i64NV = _link_function('glProgramUniform3i64NV', None, [GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11433
glProgramUniform4i64NV = _link_function('glProgramUniform4i64NV', None, [GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11434
glProgramUniform1i64vNV = _link_function('glProgramUniform1i64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11435
glProgramUniform2i64vNV = _link_function('glProgramUniform2i64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11436
glProgramUniform3i64vNV = _link_function('glProgramUniform3i64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11437
glProgramUniform4i64vNV = _link_function('glProgramUniform4i64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11438
glProgramUniform1ui64NV = _link_function('glProgramUniform1ui64NV', None, [GLuint, GLint, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11439
glProgramUniform2ui64NV = _link_function('glProgramUniform2ui64NV', None, [GLuint, GLint, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11440
glProgramUniform3ui64NV = _link_function('glProgramUniform3ui64NV', None, [GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11441
glProgramUniform4ui64NV = _link_function('glProgramUniform4ui64NV', None, [GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_gpu_shader5')
# GL/glext.h:11442
glProgramUniform1ui64vNV = _link_function('glProgramUniform1ui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11443
glProgramUniform2ui64vNV = _link_function('glProgramUniform2ui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11444
glProgramUniform3ui64vNV = _link_function('glProgramUniform3ui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
# GL/glext.h:11445
glProgramUniform4ui64vNV = _link_function('glProgramUniform4ui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64EXT)], 'NV_gpu_shader5')
PFNGLUNIFORM1I64NVPROC = CFUNCTYPE(None, GLint, GLint64EXT) # GL/glext.h:11447
PFNGLUNIFORM2I64NVPROC = CFUNCTYPE(None, GLint, GLint64EXT, GLint64EXT) # GL/glext.h:11448
PFNGLUNIFORM3I64NVPROC = CFUNCTYPE(None, GLint, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11449
PFNGLUNIFORM4I64NVPROC = CFUNCTYPE(None, GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11450
PFNGLUNIFORM1I64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11451
PFNGLUNIFORM2I64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11452
PFNGLUNIFORM3I64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11453
PFNGLUNIFORM4I64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11454
PFNGLUNIFORM1UI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT) # GL/glext.h:11455
PFNGLUNIFORM2UI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT, GLuint64EXT) # GL/glext.h:11456
PFNGLUNIFORM3UI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11457
PFNGLUNIFORM4UI64NVPROC = CFUNCTYPE(None, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11458
PFNGLUNIFORM1UI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11459
PFNGLUNIFORM2UI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11460
PFNGLUNIFORM3UI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11461
PFNGLUNIFORM4UI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11462
PFNGLGETUNIFORMI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, POINTER(GLint64EXT)) # GL/glext.h:11463
PFNGLPROGRAMUNIFORM1I64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLint64EXT) # GL/glext.h:11464
PFNGLPROGRAMUNIFORM2I64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLint64EXT, GLint64EXT) # GL/glext.h:11465
PFNGLPROGRAMUNIFORM3I64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11466
PFNGLPROGRAMUNIFORM4I64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11467
PFNGLPROGRAMUNIFORM1I64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11468
PFNGLPROGRAMUNIFORM2I64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11469
PFNGLPROGRAMUNIFORM3I64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11470
PFNGLPROGRAMUNIFORM4I64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLint64EXT)) # GL/glext.h:11471
PFNGLPROGRAMUNIFORM1UI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT) # GL/glext.h:11472
PFNGLPROGRAMUNIFORM2UI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT, GLuint64EXT) # GL/glext.h:11473
PFNGLPROGRAMUNIFORM3UI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11474
PFNGLPROGRAMUNIFORM4UI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11475
PFNGLPROGRAMUNIFORM1UI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11476
PFNGLPROGRAMUNIFORM2UI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11477
PFNGLPROGRAMUNIFORM3UI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11478
PFNGLPROGRAMUNIFORM4UI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64EXT)) # GL/glext.h:11479
# NV_shader_buffer_store (GL/glext.h:11482)
GL_NV_shader_buffer_store = 1 # GL/glext.h:11483
# NV_tessellation_program5 (GL/glext.h:11486)
GL_NV_tessellation_program5 = 1 # GL/glext.h:11487
# NV_vertex_attrib_integer_64bit (GL/glext.h:11490)
GL_NV_vertex_attrib_integer_64bit = 1 # GL/glext.h:11491
# GL/glext.h:11493
glVertexAttribL1i64NV = _link_function('glVertexAttribL1i64NV', None, [GLuint, GLint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11494
glVertexAttribL2i64NV = _link_function('glVertexAttribL2i64NV', None, [GLuint, GLint64EXT, GLint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11495
glVertexAttribL3i64NV = _link_function('glVertexAttribL3i64NV', None, [GLuint, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11496
glVertexAttribL4i64NV = _link_function('glVertexAttribL4i64NV', None, [GLuint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11497
glVertexAttribL1i64vNV = _link_function('glVertexAttribL1i64vNV', None, [GLuint, POINTER(GLint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11498
glVertexAttribL2i64vNV = _link_function('glVertexAttribL2i64vNV', None, [GLuint, POINTER(GLint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11499
glVertexAttribL3i64vNV = _link_function('glVertexAttribL3i64vNV', None, [GLuint, POINTER(GLint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11500
glVertexAttribL4i64vNV = _link_function('glVertexAttribL4i64vNV', None, [GLuint, POINTER(GLint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11501
glVertexAttribL1ui64NV = _link_function('glVertexAttribL1ui64NV', None, [GLuint, GLuint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11502
glVertexAttribL2ui64NV = _link_function('glVertexAttribL2ui64NV', None, [GLuint, GLuint64EXT, GLuint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11503
glVertexAttribL3ui64NV = _link_function('glVertexAttribL3ui64NV', None, [GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11504
glVertexAttribL4ui64NV = _link_function('glVertexAttribL4ui64NV', None, [GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11505
glVertexAttribL1ui64vNV = _link_function('glVertexAttribL1ui64vNV', None, [GLuint, POINTER(GLuint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11506
glVertexAttribL2ui64vNV = _link_function('glVertexAttribL2ui64vNV', None, [GLuint, POINTER(GLuint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11507
glVertexAttribL3ui64vNV = _link_function('glVertexAttribL3ui64vNV', None, [GLuint, POINTER(GLuint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11508
glVertexAttribL4ui64vNV = _link_function('glVertexAttribL4ui64vNV', None, [GLuint, POINTER(GLuint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11509
glGetVertexAttribLi64vNV = _link_function('glGetVertexAttribLi64vNV', None, [GLuint, GLenum, POINTER(GLint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11510
glGetVertexAttribLui64vNV = _link_function('glGetVertexAttribLui64vNV', None, [GLuint, GLenum, POINTER(GLuint64EXT)], 'NV_vertex_attrib_integer_64bit')
# GL/glext.h:11511
glVertexAttribLFormatNV = _link_function('glVertexAttribLFormatNV', None, [GLuint, GLint, GLenum, GLsizei], 'NV_vertex_attrib_integer_64bit')
PFNGLVERTEXATTRIBL1I64NVPROC = CFUNCTYPE(None, GLuint, GLint64EXT) # GL/glext.h:11513
PFNGLVERTEXATTRIBL2I64NVPROC = CFUNCTYPE(None, GLuint, GLint64EXT, GLint64EXT) # GL/glext.h:11514
PFNGLVERTEXATTRIBL3I64NVPROC = CFUNCTYPE(None, GLuint, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11515
PFNGLVERTEXATTRIBL4I64NVPROC = CFUNCTYPE(None, GLuint, GLint64EXT, GLint64EXT, GLint64EXT, GLint64EXT) # GL/glext.h:11516
PFNGLVERTEXATTRIBL1I64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint64EXT)) # GL/glext.h:11517
PFNGLVERTEXATTRIBL2I64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint64EXT)) # GL/glext.h:11518
PFNGLVERTEXATTRIBL3I64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint64EXT)) # GL/glext.h:11519
PFNGLVERTEXATTRIBL4I64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLint64EXT)) # GL/glext.h:11520
PFNGLVERTEXATTRIBL1UI64NVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT) # GL/glext.h:11521
PFNGLVERTEXATTRIBL2UI64NVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint64EXT) # GL/glext.h:11522
PFNGLVERTEXATTRIBL3UI64NVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11523
PFNGLVERTEXATTRIBL4UI64NVPROC = CFUNCTYPE(None, GLuint, GLuint64EXT, GLuint64EXT, GLuint64EXT, GLuint64EXT) # GL/glext.h:11524
PFNGLVERTEXATTRIBL1UI64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:11525
PFNGLVERTEXATTRIBL2UI64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:11526
PFNGLVERTEXATTRIBL3UI64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:11527
PFNGLVERTEXATTRIBL4UI64VNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLuint64EXT)) # GL/glext.h:11528
PFNGLGETVERTEXATTRIBLI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint64EXT)) # GL/glext.h:11529
PFNGLGETVERTEXATTRIBLUI64VNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLuint64EXT)) # GL/glext.h:11530
PFNGLVERTEXATTRIBLFORMATNVPROC = CFUNCTYPE(None, GLuint, GLint, GLenum, GLsizei) # GL/glext.h:11531
# NV_multisample_coverage (GL/glext.h:11534)
GL_NV_multisample_coverage = 1 # GL/glext.h:11535
# AMD_name_gen_delete (GL/glext.h:11538)
GL_AMD_name_gen_delete = 1 # GL/glext.h:11539
# GL/glext.h:11541
glGenNamesAMD = _link_function('glGenNamesAMD', None, [GLenum, GLuint, POINTER(GLuint)], 'AMD_name_gen_delete')
# GL/glext.h:11542
glDeleteNamesAMD = _link_function('glDeleteNamesAMD', None, [GLenum, GLuint, POINTER(GLuint)], 'AMD_name_gen_delete')
# GL/glext.h:11543
glIsNameAMD = _link_function('glIsNameAMD', GLboolean, [GLenum, GLuint], 'AMD_name_gen_delete')
PFNGLGENNAMESAMDPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:11545
PFNGLDELETENAMESAMDPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLuint)) # GL/glext.h:11546
PFNGLISNAMEAMDPROC = CFUNCTYPE(GLboolean, GLenum, GLuint) # GL/glext.h:11547
# AMD_debug_output (GL/glext.h:11550)
GL_AMD_debug_output = 1 # GL/glext.h:11551
# GL/glext.h:11553
glDebugMessageEnableAMD = _link_function('glDebugMessageEnableAMD', None, [GLenum, GLenum, GLsizei, POINTER(GLuint), GLboolean], 'AMD_debug_output')
# GL/glext.h:11554
glDebugMessageInsertAMD = _link_function('glDebugMessageInsertAMD', None, [GLenum, GLenum, GLuint, GLsizei, POINTER(GLchar)], 'AMD_debug_output')
# GL/glext.h:11555
glDebugMessageCallbackAMD = _link_function('glDebugMessageCallbackAMD', None, [GLDEBUGPROCAMD, POINTER(GLvoid)], 'AMD_debug_output')
# GL/glext.h:11556
glGetDebugMessageLogAMD = _link_function('glGetDebugMessageLogAMD', GLuint, [GLuint, GLsizei, POINTER(GLenum), POINTER(GLuint), POINTER(GLuint), POINTER(GLsizei), POINTER(GLchar)], 'AMD_debug_output')
PFNGLDEBUGMESSAGEENABLEAMDPROC = CFUNCTYPE(None, GLenum, GLenum, GLsizei, POINTER(GLuint), GLboolean) # GL/glext.h:11558
PFNGLDEBUGMESSAGEINSERTAMDPROC = CFUNCTYPE(None, GLenum, GLenum, GLuint, GLsizei, POINTER(GLchar)) # GL/glext.h:11559
PFNGLDEBUGMESSAGECALLBACKAMDPROC = CFUNCTYPE(None, GLDEBUGPROCAMD, POINTER(GLvoid)) # GL/glext.h:11560
PFNGLGETDEBUGMESSAGELOGAMDPROC = CFUNCTYPE(GLuint, GLuint, GLsizei, POINTER(GLenum), POINTER(GLuint), POINTER(GLuint), POINTER(GLsizei), POINTER(GLchar)) # GL/glext.h:11561
# NV_vdpau_interop (GL/glext.h:11564)
GL_NV_vdpau_interop = 1 # GL/glext.h:11565
# GL/glext.h:11567
glVDPAUInitNV = _link_function('glVDPAUInitNV', None, [POINTER(GLvoid), POINTER(GLvoid)], 'NV_vdpau_interop')
# GL/glext.h:11568
glVDPAUFiniNV = _link_function('glVDPAUFiniNV', None, [], 'NV_vdpau_interop')
# GL/glext.h:11569
glVDPAURegisterVideoSurfaceNV = _link_function('glVDPAURegisterVideoSurfaceNV', GLvdpauSurfaceNV, [POINTER(GLvoid), GLenum, GLsizei, POINTER(GLuint)], 'NV_vdpau_interop')
# GL/glext.h:11570
glVDPAURegisterOutputSurfaceNV = _link_function('glVDPAURegisterOutputSurfaceNV', GLvdpauSurfaceNV, [POINTER(GLvoid), GLenum, GLsizei, POINTER(GLuint)], 'NV_vdpau_interop')
# GL/glext.h:11571
glVDPAUIsSurfaceNV = _link_function('glVDPAUIsSurfaceNV', None, [GLvdpauSurfaceNV], 'NV_vdpau_interop')
# GL/glext.h:11572
glVDPAUUnregisterSurfaceNV = _link_function('glVDPAUUnregisterSurfaceNV', None, [GLvdpauSurfaceNV], 'NV_vdpau_interop')
# GL/glext.h:11573
glVDPAUGetSurfaceivNV = _link_function('glVDPAUGetSurfaceivNV', None, [GLvdpauSurfaceNV, GLenum, GLsizei, POINTER(GLsizei), POINTER(GLint)], 'NV_vdpau_interop')
# GL/glext.h:11574
glVDPAUSurfaceAccessNV = _link_function('glVDPAUSurfaceAccessNV', None, [GLvdpauSurfaceNV, GLenum], 'NV_vdpau_interop')
# GL/glext.h:11575
glVDPAUMapSurfacesNV = _link_function('glVDPAUMapSurfacesNV', None, [GLsizei, POINTER(GLvdpauSurfaceNV)], 'NV_vdpau_interop')
# GL/glext.h:11576
glVDPAUUnmapSurfacesNV = _link_function('glVDPAUUnmapSurfacesNV', None, [GLsizei, POINTER(GLvdpauSurfaceNV)], 'NV_vdpau_interop')
PFNGLVDPAUINITNVPROC = CFUNCTYPE(None, POINTER(GLvoid), POINTER(GLvoid)) # GL/glext.h:11578
PFNGLVDPAUFININVPROC = CFUNCTYPE(None) # GL/glext.h:11579
PFNGLVDPAUREGISTERVIDEOSURFACENVPROC = CFUNCTYPE(GLvdpauSurfaceNV, POINTER(GLvoid), GLenum, GLsizei, POINTER(GLuint)) # GL/glext.h:11580
PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC = CFUNCTYPE(GLvdpauSurfaceNV, POINTER(GLvoid), GLenum, GLsizei, POINTER(GLuint)) # GL/glext.h:11581
PFNGLVDPAUISSURFACENVPROC = CFUNCTYPE(None, GLvdpauSurfaceNV) # GL/glext.h:11582
PFNGLVDPAUUNREGISTERSURFACENVPROC = CFUNCTYPE(None, GLvdpauSurfaceNV) # GL/glext.h:11583
PFNGLVDPAUGETSURFACEIVNVPROC = CFUNCTYPE(None, GLvdpauSurfaceNV, GLenum, GLsizei, POINTER(GLsizei), POINTER(GLint)) # GL/glext.h:11584
PFNGLVDPAUSURFACEACCESSNVPROC = CFUNCTYPE(None, GLvdpauSurfaceNV, GLenum) # GL/glext.h:11585
PFNGLVDPAUMAPSURFACESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvdpauSurfaceNV)) # GL/glext.h:11586
PFNGLVDPAUUNMAPSURFACESNVPROC = CFUNCTYPE(None, GLsizei, POINTER(GLvdpauSurfaceNV)) # GL/glext.h:11587
# AMD_transform_feedback3_lines_triangles (GL/glext.h:11590)
GL_AMD_transform_feedback3_lines_triangles = 1 # GL/glext.h:11591
# AMD_depth_clamp_separate (GL/glext.h:11594)
GL_AMD_depth_clamp_separate = 1 # GL/glext.h:11595
# EXT_texture_sRGB_decode (GL/glext.h:11598)
GL_EXT_texture_sRGB_decode = 1 # GL/glext.h:11599
# NV_texture_multisample (GL/glext.h:11602)
GL_NV_texture_multisample = 1 # GL/glext.h:11603
# GL/glext.h:11605
glTexImage2DMultisampleCoverageNV = _link_function('glTexImage2DMultisampleCoverageNV', None, [GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
# GL/glext.h:11606
glTexImage3DMultisampleCoverageNV = _link_function('glTexImage3DMultisampleCoverageNV', None, [GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
# GL/glext.h:11607
glTextureImage2DMultisampleNV = _link_function('glTextureImage2DMultisampleNV', None, [GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
# GL/glext.h:11608
glTextureImage3DMultisampleNV = _link_function('glTextureImage3DMultisampleNV', None, [GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
# GL/glext.h:11609
glTextureImage2DMultisampleCoverageNV = _link_function('glTextureImage2DMultisampleCoverageNV', None, [GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
# GL/glext.h:11610
glTextureImage3DMultisampleCoverageNV = _link_function('glTextureImage3DMultisampleCoverageNV', None, [GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean], 'NV_texture_multisample')
PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean) # GL/glext.h:11612
PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) # GL/glext.h:11613
PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean) # GL/glext.h:11614
PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) # GL/glext.h:11615
PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean) # GL/glext.h:11616
PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean) # GL/glext.h:11617
# AMD_blend_minmax_factor (GL/glext.h:11620)
GL_AMD_blend_minmax_factor = 1 # GL/glext.h:11621
# AMD_sample_positions (GL/glext.h:11624)
GL_AMD_sample_positions = 1 # GL/glext.h:11625
# GL/glext.h:11627
glSetMultisamplefvAMD = _link_function('glSetMultisamplefvAMD', None, [GLenum, GLuint, POINTER(GLfloat)], 'AMD_sample_positions')
PFNGLSETMULTISAMPLEFVAMDPROC = CFUNCTYPE(None, GLenum, GLuint, POINTER(GLfloat)) # GL/glext.h:11629
# EXT_x11_sync_object (GL/glext.h:11632)
GL_EXT_x11_sync_object = 1 # GL/glext.h:11633
# GL/glext.h:11635
glImportSyncEXT = _link_function('glImportSyncEXT', GLsync, [GLenum, GLintptr, GLbitfield], 'EXT_x11_sync_object')
PFNGLIMPORTSYNCEXTPROC = CFUNCTYPE(GLsync, GLenum, GLintptr, GLbitfield) # GL/glext.h:11637
# AMD_multi_draw_indirect (GL/glext.h:11640)
GL_AMD_multi_draw_indirect = 1 # GL/glext.h:11641
# GL/glext.h:11643
glMultiDrawArraysIndirectAMD = _link_function('glMultiDrawArraysIndirectAMD', None, [GLenum, POINTER(GLvoid), GLsizei, GLsizei], 'AMD_multi_draw_indirect')
# GL/glext.h:11644
glMultiDrawElementsIndirectAMD = _link_function('glMultiDrawElementsIndirectAMD', None, [GLenum, GLenum, POINTER(GLvoid), GLsizei, GLsizei], 'AMD_multi_draw_indirect')
PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC = CFUNCTYPE(None, GLenum, POINTER(GLvoid), GLsizei, GLsizei) # GL/glext.h:11646
PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLvoid), GLsizei, GLsizei) # GL/glext.h:11647
# EXT_framebuffer_multisample_blit_scaled (GL/glext.h:11650)
GL_EXT_framebuffer_multisample_blit_scaled = 1 # GL/glext.h:11651
# NV_path_rendering (GL/glext.h:11654)
GL_NV_path_rendering = 1 # GL/glext.h:11655
# GL/glext.h:11657
glGenPathsNV = _link_function('glGenPathsNV', GLuint, [GLsizei], 'NV_path_rendering')
# GL/glext.h:11658
glDeletePathsNV = _link_function('glDeletePathsNV', None, [GLuint, GLsizei], 'NV_path_rendering')
# GL/glext.h:11659
glIsPathNV = _link_function('glIsPathNV', GLboolean, [GLuint], 'NV_path_rendering')
# GL/glext.h:11660
glPathCommandsNV = _link_function('glPathCommandsNV', None, [GLuint, GLsizei, POINTER(GLubyte), GLsizei, GLenum, POINTER(GLvoid)], 'NV_path_rendering')
# GL/glext.h:11661
glPathCoordsNV = _link_function('glPathCoordsNV', None, [GLuint, GLsizei, GLenum, POINTER(GLvoid)], 'NV_path_rendering')
# GL/glext.h:11662
glPathSubCommandsNV = _link_function('glPathSubCommandsNV', None, [GLuint, GLsizei, GLsizei, GLsizei, POINTER(GLubyte), GLsizei, GLenum, POINTER(GLvoid)], 'NV_path_rendering')
# GL/glext.h:11663
glPathSubCoordsNV = _link_function('glPathSubCoordsNV', None, [GLuint, GLsizei, GLsizei, GLenum, POINTER(GLvoid)], 'NV_path_rendering')
# GL/glext.h:11664
glPathStringNV = _link_function('glPathStringNV', None, [GLuint, GLenum, GLsizei, POINTER(GLvoid)], 'NV_path_rendering')
# GL/glext.h:11665
glPathGlyphsNV = _link_function('glPathGlyphsNV', None, [GLuint, GLenum, POINTER(GLvoid), GLbitfield, GLsizei, GLenum, POINTER(GLvoid), GLenum, GLuint, GLfloat], 'NV_path_rendering')
# GL/glext.h:11666
glPathGlyphRangeNV = _link_function('glPathGlyphRangeNV', None, [GLuint, GLenum, POINTER(GLvoid), GLbitfield, GLuint, GLsizei, GLenum, GLuint, GLfloat], 'NV_path_rendering')
# GL/glext.h:11667
glWeightPathsNV = _link_function('glWeightPathsNV', None, [GLuint, GLsizei, POINTER(GLuint), POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11668
glCopyPathNV = _link_function('glCopyPathNV', None, [GLuint, GLuint], 'NV_path_rendering')
# GL/glext.h:11669
glInterpolatePathsNV = _link_function('glInterpolatePathsNV', None, [GLuint, GLuint, GLuint, GLfloat], 'NV_path_rendering')
# GL/glext.h:11670
glTransformPathNV = _link_function('glTransformPathNV', None, [GLuint, GLuint, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11671
glPathParameterivNV = _link_function('glPathParameterivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_path_rendering')
# GL/glext.h:11672
glPathParameteriNV = _link_function('glPathParameteriNV', None, [GLuint, GLenum, GLint], 'NV_path_rendering')
# GL/glext.h:11673
glPathParameterfvNV = _link_function('glPathParameterfvNV', None, [GLuint, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11674
glPathParameterfNV = _link_function('glPathParameterfNV', None, [GLuint, GLenum, GLfloat], 'NV_path_rendering')
# GL/glext.h:11675
glPathDashArrayNV = _link_function('glPathDashArrayNV', None, [GLuint, GLsizei, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11676
glPathStencilFuncNV = _link_function('glPathStencilFuncNV', None, [GLenum, GLint, GLuint], 'NV_path_rendering')
# GL/glext.h:11677
glPathStencilDepthOffsetNV = _link_function('glPathStencilDepthOffsetNV', None, [GLfloat, GLfloat], 'NV_path_rendering')
# GL/glext.h:11678
glStencilFillPathNV = _link_function('glStencilFillPathNV', None, [GLuint, GLenum, GLuint], 'NV_path_rendering')
# GL/glext.h:11679
glStencilStrokePathNV = _link_function('glStencilStrokePathNV', None, [GLuint, GLint, GLuint], 'NV_path_rendering')
# GL/glext.h:11680
glStencilFillPathInstancedNV = _link_function('glStencilFillPathInstancedNV', None, [GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLuint, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11681
glStencilStrokePathInstancedNV = _link_function('glStencilStrokePathInstancedNV', None, [GLsizei, GLenum, POINTER(GLvoid), GLuint, GLint, GLuint, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11682
glPathCoverDepthFuncNV = _link_function('glPathCoverDepthFuncNV', None, [GLenum], 'NV_path_rendering')
# GL/glext.h:11683
glPathColorGenNV = _link_function('glPathColorGenNV', None, [GLenum, GLenum, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11684
glPathTexGenNV = _link_function('glPathTexGenNV', None, [GLenum, GLenum, GLint, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11685
glPathFogGenNV = _link_function('glPathFogGenNV', None, [GLenum], 'NV_path_rendering')
# GL/glext.h:11686
glCoverFillPathNV = _link_function('glCoverFillPathNV', None, [GLuint, GLenum], 'NV_path_rendering')
# GL/glext.h:11687
glCoverStrokePathNV = _link_function('glCoverStrokePathNV', None, [GLuint, GLenum], 'NV_path_rendering')
# GL/glext.h:11688
glCoverFillPathInstancedNV = _link_function('glCoverFillPathInstancedNV', None, [GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11689
glCoverStrokePathInstancedNV = _link_function('glCoverStrokePathInstancedNV', None, [GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11690
glGetPathParameterivNV = _link_function('glGetPathParameterivNV', None, [GLuint, GLenum, POINTER(GLint)], 'NV_path_rendering')
# GL/glext.h:11691
glGetPathParameterfvNV = _link_function('glGetPathParameterfvNV', None, [GLuint, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11692
glGetPathCommandsNV = _link_function('glGetPathCommandsNV', None, [GLuint, POINTER(GLubyte)], 'NV_path_rendering')
# GL/glext.h:11693
glGetPathCoordsNV = _link_function('glGetPathCoordsNV', None, [GLuint, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11694
glGetPathDashArrayNV = _link_function('glGetPathDashArrayNV', None, [GLuint, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11695
glGetPathMetricsNV = _link_function('glGetPathMetricsNV', None, [GLbitfield, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLsizei, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11696
glGetPathMetricRangeNV = _link_function('glGetPathMetricRangeNV', None, [GLbitfield, GLuint, GLsizei, GLsizei, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11697
glGetPathSpacingNV = _link_function('glGetPathSpacingNV', None, [GLenum, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLfloat, GLfloat, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11698
glGetPathColorGenivNV = _link_function('glGetPathColorGenivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_path_rendering')
# GL/glext.h:11699
glGetPathColorGenfvNV = _link_function('glGetPathColorGenfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11700
glGetPathTexGenivNV = _link_function('glGetPathTexGenivNV', None, [GLenum, GLenum, POINTER(GLint)], 'NV_path_rendering')
# GL/glext.h:11701
glGetPathTexGenfvNV = _link_function('glGetPathTexGenfvNV', None, [GLenum, GLenum, POINTER(GLfloat)], 'NV_path_rendering')
# GL/glext.h:11702
glIsPointInFillPathNV = _link_function('glIsPointInFillPathNV', GLboolean, [GLuint, GLuint, GLfloat, GLfloat], 'NV_path_rendering')
# GL/glext.h:11703
glIsPointInStrokePathNV = _link_function('glIsPointInStrokePathNV', GLboolean, [GLuint, GLfloat, GLfloat], 'NV_path_rendering')
# GL/glext.h:11704
glGetPathLengthNV = _link_function('glGetPathLengthNV', GLfloat, [GLuint, GLsizei, GLsizei], 'NV_path_rendering')
# GL/glext.h:11705
glPointAlongPathNV = _link_function('glPointAlongPathNV', GLboolean, [GLuint, GLsizei, GLsizei, GLfloat, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)], 'NV_path_rendering')
PFNGLGENPATHSNVPROC = CFUNCTYPE(GLuint, GLsizei) # GL/glext.h:11707
PFNGLDELETEPATHSNVPROC = CFUNCTYPE(None, GLuint, GLsizei) # GL/glext.h:11708
PFNGLISPATHNVPROC = CFUNCTYPE(GLboolean, GLuint) # GL/glext.h:11709
PFNGLPATHCOMMANDSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLubyte), GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:11710
PFNGLPATHCOORDSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:11711
PFNGLPATHSUBCOMMANDSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, GLsizei, GLsizei, POINTER(GLubyte), GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:11712
PFNGLPATHSUBCOORDSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, GLsizei, GLenum, POINTER(GLvoid)) # GL/glext.h:11713
PFNGLPATHSTRINGNVPROC = CFUNCTYPE(None, GLuint, GLenum, GLsizei, POINTER(GLvoid)) # GL/glext.h:11714
PFNGLPATHGLYPHSNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid), GLbitfield, GLsizei, GLenum, POINTER(GLvoid), GLenum, GLuint, GLfloat) # GL/glext.h:11715
PFNGLPATHGLYPHRANGENVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLvoid), GLbitfield, GLuint, GLsizei, GLenum, GLuint, GLfloat) # GL/glext.h:11716
PFNGLWEIGHTPATHSNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLuint), POINTER(GLfloat)) # GL/glext.h:11717
PFNGLCOPYPATHNVPROC = CFUNCTYPE(None, GLuint, GLuint) # GL/glext.h:11718
PFNGLINTERPOLATEPATHSNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLuint, GLfloat) # GL/glext.h:11719
PFNGLTRANSFORMPATHNVPROC = CFUNCTYPE(None, GLuint, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11720
PFNGLPATHPARAMETERIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11721
PFNGLPATHPARAMETERINVPROC = CFUNCTYPE(None, GLuint, GLenum, GLint) # GL/glext.h:11722
PFNGLPATHPARAMETERFVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11723
PFNGLPATHPARAMETERFNVPROC = CFUNCTYPE(None, GLuint, GLenum, GLfloat) # GL/glext.h:11724
PFNGLPATHDASHARRAYNVPROC = CFUNCTYPE(None, GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:11725
PFNGLPATHSTENCILFUNCNVPROC = CFUNCTYPE(None, GLenum, GLint, GLuint) # GL/glext.h:11726
PFNGLPATHSTENCILDEPTHOFFSETNVPROC = CFUNCTYPE(None, GLfloat, GLfloat) # GL/glext.h:11727
PFNGLSTENCILFILLPATHNVPROC = CFUNCTYPE(None, GLuint, GLenum, GLuint) # GL/glext.h:11728
PFNGLSTENCILSTROKEPATHNVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint) # GL/glext.h:11729
PFNGLSTENCILFILLPATHINSTANCEDNVPROC = CFUNCTYPE(None, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11730
PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC = CFUNCTYPE(None, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLint, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11731
PFNGLPATHCOVERDEPTHFUNCNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:11732
PFNGLPATHCOLORGENNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:11733
PFNGLPATHTEXGENNVPROC = CFUNCTYPE(None, GLenum, GLenum, GLint, POINTER(GLfloat)) # GL/glext.h:11734
PFNGLPATHFOGGENNVPROC = CFUNCTYPE(None, GLenum) # GL/glext.h:11735
PFNGLCOVERFILLPATHNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11736
PFNGLCOVERSTROKEPATHNVPROC = CFUNCTYPE(None, GLuint, GLenum) # GL/glext.h:11737
PFNGLCOVERFILLPATHINSTANCEDNVPROC = CFUNCTYPE(None, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:11738
PFNGLCOVERSTROKEPATHINSTANCEDNVPROC = CFUNCTYPE(None, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:11739
PFNGLGETPATHPARAMETERIVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLint)) # GL/glext.h:11740
PFNGLGETPATHPARAMETERFVNVPROC = CFUNCTYPE(None, GLuint, GLenum, POINTER(GLfloat)) # GL/glext.h:11741
PFNGLGETPATHCOMMANDSNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLubyte)) # GL/glext.h:11742
PFNGLGETPATHCOORDSNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:11743
PFNGLGETPATHDASHARRAYNVPROC = CFUNCTYPE(None, GLuint, POINTER(GLfloat)) # GL/glext.h:11744
PFNGLGETPATHMETRICSNVPROC = CFUNCTYPE(None, GLbitfield, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLsizei, POINTER(GLfloat)) # GL/glext.h:11745
PFNGLGETPATHMETRICRANGENVPROC = CFUNCTYPE(None, GLbitfield, GLuint, GLsizei, GLsizei, POINTER(GLfloat)) # GL/glext.h:11746
PFNGLGETPATHSPACINGNVPROC = CFUNCTYPE(None, GLenum, GLsizei, GLenum, POINTER(GLvoid), GLuint, GLfloat, GLfloat, GLenum, POINTER(GLfloat)) # GL/glext.h:11747
PFNGLGETPATHCOLORGENIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:11748
PFNGLGETPATHCOLORGENFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:11749
PFNGLGETPATHTEXGENIVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLint)) # GL/glext.h:11750
PFNGLGETPATHTEXGENFVNVPROC = CFUNCTYPE(None, GLenum, GLenum, POINTER(GLfloat)) # GL/glext.h:11751
PFNGLISPOINTINFILLPATHNVPROC = CFUNCTYPE(GLboolean, GLuint, GLuint, GLfloat, GLfloat) # GL/glext.h:11752
PFNGLISPOINTINSTROKEPATHNVPROC = CFUNCTYPE(GLboolean, GLuint, GLfloat, GLfloat) # GL/glext.h:11753
PFNGLGETPATHLENGTHNVPROC = CFUNCTYPE(GLfloat, GLuint, GLsizei, GLsizei) # GL/glext.h:11754
PFNGLPOINTALONGPATHNVPROC = CFUNCTYPE(GLboolean, GLuint, GLsizei, GLsizei, GLfloat, POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat), POINTER(GLfloat)) # GL/glext.h:11755
# AMD_pinned_memory (GL/glext.h:11758)
GL_AMD_pinned_memory = 1 # GL/glext.h:11759
# AMD_stencil_operation_extended (GL/glext.h:11762)
GL_AMD_stencil_operation_extended = 1 # GL/glext.h:11763
# GL/glext.h:11765
glStencilOpValueAMD = _link_function('glStencilOpValueAMD', None, [GLenum, GLuint], 'AMD_stencil_operation_extended')
PFNGLSTENCILOPVALUEAMDPROC = CFUNCTYPE(None, GLenum, GLuint) # GL/glext.h:11767
# AMD_vertex_shader_viewport_index (GL/glext.h:11770)
GL_AMD_vertex_shader_viewport_index = 1 # GL/glext.h:11771
# AMD_vertex_shader_layer (GL/glext.h:11774)
GL_AMD_vertex_shader_layer = 1 # GL/glext.h:11775
# NV_bindless_texture (GL/glext.h:11778)
GL_NV_bindless_texture = 1 # GL/glext.h:11779
# GL/glext.h:11781
glGetTextureHandleNV = _link_function('glGetTextureHandleNV', GLuint64, [GLuint], 'NV_bindless_texture')
# GL/glext.h:11782
glGetTextureSamplerHandleNV = _link_function('glGetTextureSamplerHandleNV', GLuint64, [GLuint, GLuint], 'NV_bindless_texture')
# GL/glext.h:11783
glMakeTextureHandleResidentNV = _link_function('glMakeTextureHandleResidentNV', None, [GLuint64], 'NV_bindless_texture')
# GL/glext.h:11784
glMakeTextureHandleNonResidentNV = _link_function('glMakeTextureHandleNonResidentNV', None, [GLuint64], 'NV_bindless_texture')
# GL/glext.h:11785
glGetImageHandleNV = _link_function('glGetImageHandleNV', GLuint64, [GLuint, GLint, GLboolean, GLint, GLenum], 'NV_bindless_texture')
# GL/glext.h:11786
glMakeImageHandleResidentNV = _link_function('glMakeImageHandleResidentNV', None, [GLuint64, GLenum], 'NV_bindless_texture')
# GL/glext.h:11787
glMakeImageHandleNonResidentNV = _link_function('glMakeImageHandleNonResidentNV', None, [GLuint64], 'NV_bindless_texture')
# GL/glext.h:11788
glUniformHandleui64NV = _link_function('glUniformHandleui64NV', None, [GLint, GLuint64], 'NV_bindless_texture')
# GL/glext.h:11789
glUniformHandleui64vNV = _link_function('glUniformHandleui64vNV', None, [GLint, GLsizei, POINTER(GLuint64)], 'NV_bindless_texture')
# GL/glext.h:11790
glProgramUniformHandleui64NV = _link_function('glProgramUniformHandleui64NV', None, [GLuint, GLint, GLuint64], 'NV_bindless_texture')
# GL/glext.h:11791
glProgramUniformHandleui64vNV = _link_function('glProgramUniformHandleui64vNV', None, [GLuint, GLint, GLsizei, POINTER(GLuint64)], 'NV_bindless_texture')
# GL/glext.h:11792
glIsTextureHandleResidentNV = _link_function('glIsTextureHandleResidentNV', GLboolean, [GLuint64], 'NV_bindless_texture')
# GL/glext.h:11793
glIsImageHandleResidentNV = _link_function('glIsImageHandleResidentNV', GLboolean, [GLuint64], 'NV_bindless_texture')
PFNGLGETTEXTUREHANDLENVPROC = CFUNCTYPE(GLuint64, GLuint) # GL/glext.h:11795
PFNGLGETTEXTURESAMPLERHANDLENVPROC = CFUNCTYPE(GLuint64, GLuint, GLuint) # GL/glext.h:11796
PFNGLMAKETEXTUREHANDLERESIDENTNVPROC = CFUNCTYPE(None, GLuint64) # GL/glext.h:11797
PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC = CFUNCTYPE(None, GLuint64) # GL/glext.h:11798
PFNGLGETIMAGEHANDLENVPROC = CFUNCTYPE(GLuint64, GLuint, GLint, GLboolean, GLint, GLenum) # GL/glext.h:11799
PFNGLMAKEIMAGEHANDLERESIDENTNVPROC = CFUNCTYPE(None, GLuint64, GLenum) # GL/glext.h:11800
PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC = CFUNCTYPE(None, GLuint64) # GL/glext.h:11801
PFNGLUNIFORMHANDLEUI64NVPROC = CFUNCTYPE(None, GLint, GLuint64) # GL/glext.h:11802
PFNGLUNIFORMHANDLEUI64VNVPROC = CFUNCTYPE(None, GLint, GLsizei, POINTER(GLuint64)) # GL/glext.h:11803
PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC = CFUNCTYPE(None, GLuint, GLint, GLuint64) # GL/glext.h:11804
PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC = CFUNCTYPE(None, GLuint, GLint, GLsizei, POINTER(GLuint64)) # GL/glext.h:11805
PFNGLISTEXTUREHANDLERESIDENTNVPROC = CFUNCTYPE(GLboolean, GLuint64) # GL/glext.h:11806
PFNGLISIMAGEHANDLERESIDENTNVPROC = CFUNCTYPE(GLboolean, GLuint64) # GL/glext.h:11807
# NV_shader_atomic_float (GL/glext.h:11810)
GL_NV_shader_atomic_float = 1 # GL/glext.h:11811
# AMD_query_buffer_object (GL/glext.h:11814)
GL_AMD_query_buffer_object = 1 # GL/glext.h:11815
# MESA_shader_debug (/usr/include/GL/gl.h:2093)
# MESA_packed_depth_stencil (/usr/include/GL/gl.h:2115)
# MESA_program_debug (/usr/include/GL/gl.h:2127)
# MESA_texture_array (/usr/include/GL/gl.h:2148)
# EXT_texture_array (/usr/include/GL/gl.h:2153)
# ATI_blend_equation_separate (/usr/include/GL/gl.h:2181)
# OES_EGL_image (/usr/include/GL/gl.h:2193)
# OES_EGL_image (/usr/include/GL/gl.h:2197)
__all__ = ['GL_GLEXT_VERSION', 'GL_RESCALE_NORMAL',
'GL_LIGHT_MODEL_COLOR_CONTROL', 'GL_SINGLE_COLOR',
'GL_SEPARATE_SPECULAR_COLOR', 'GL_ALIASED_POINT_SIZE_RANGE',
'GL_CONVOLUTION_1D', 'GL_CONVOLUTION_2D', 'GL_SEPARABLE_2D',
'GL_CONVOLUTION_BORDER_MODE', 'GL_CONVOLUTION_FILTER_SCALE',
'GL_CONVOLUTION_FILTER_BIAS', 'GL_REDUCE', 'GL_CONVOLUTION_FORMAT',
'GL_CONVOLUTION_WIDTH', 'GL_CONVOLUTION_HEIGHT', 'GL_MAX_CONVOLUTION_WIDTH',
'GL_MAX_CONVOLUTION_HEIGHT', 'GL_POST_CONVOLUTION_RED_SCALE',
'GL_POST_CONVOLUTION_GREEN_SCALE', 'GL_POST_CONVOLUTION_BLUE_SCALE',
'GL_POST_CONVOLUTION_ALPHA_SCALE', 'GL_POST_CONVOLUTION_RED_BIAS',
'GL_POST_CONVOLUTION_GREEN_BIAS', 'GL_POST_CONVOLUTION_BLUE_BIAS',
'GL_POST_CONVOLUTION_ALPHA_BIAS', 'GL_HISTOGRAM', 'GL_PROXY_HISTOGRAM',
'GL_HISTOGRAM_WIDTH', 'GL_HISTOGRAM_FORMAT', 'GL_HISTOGRAM_RED_SIZE',
'GL_HISTOGRAM_GREEN_SIZE', 'GL_HISTOGRAM_BLUE_SIZE',
'GL_HISTOGRAM_ALPHA_SIZE', 'GL_HISTOGRAM_LUMINANCE_SIZE', 'GL_HISTOGRAM_SINK',
'GL_MINMAX', 'GL_MINMAX_FORMAT', 'GL_MINMAX_SINK', 'GL_TABLE_TOO_LARGE',
'GL_COLOR_MATRIX', 'GL_COLOR_MATRIX_STACK_DEPTH',
'GL_MAX_COLOR_MATRIX_STACK_DEPTH', 'GL_POST_COLOR_MATRIX_RED_SCALE',
'GL_POST_COLOR_MATRIX_GREEN_SCALE', 'GL_POST_COLOR_MATRIX_BLUE_SCALE',
'GL_POST_COLOR_MATRIX_ALPHA_SCALE', 'GL_POST_COLOR_MATRIX_RED_BIAS',
'GL_POST_COLOR_MATRIX_GREEN_BIAS', 'GL_POST_COLOR_MATRIX_BLUE_BIAS',
'GL_POST_COLOR_MATRIX_ALPHA_BIAS', 'GL_COLOR_TABLE',
'GL_POST_CONVOLUTION_COLOR_TABLE', 'GL_POST_COLOR_MATRIX_COLOR_TABLE',
'GL_PROXY_COLOR_TABLE', 'GL_PROXY_POST_CONVOLUTION_COLOR_TABLE',
'GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE', 'GL_COLOR_TABLE_SCALE',
'GL_COLOR_TABLE_BIAS', 'GL_COLOR_TABLE_FORMAT', 'GL_COLOR_TABLE_WIDTH',
'GL_COLOR_TABLE_RED_SIZE', 'GL_COLOR_TABLE_GREEN_SIZE',
'GL_COLOR_TABLE_BLUE_SIZE', 'GL_COLOR_TABLE_ALPHA_SIZE',
'GL_COLOR_TABLE_LUMINANCE_SIZE', 'GL_COLOR_TABLE_INTENSITY_SIZE',
'GL_CONSTANT_BORDER', 'GL_REPLICATE_BORDER', 'GL_CONVOLUTION_BORDER_COLOR',
'GL_CLIENT_ACTIVE_TEXTURE', 'GL_MAX_TEXTURE_UNITS',
'GL_TRANSPOSE_MODELVIEW_MATRIX', 'GL_TRANSPOSE_PROJECTION_MATRIX',
'GL_TRANSPOSE_TEXTURE_MATRIX', 'GL_TRANSPOSE_COLOR_MATRIX',
'GL_MULTISAMPLE_BIT', 'GL_NORMAL_MAP', 'GL_REFLECTION_MAP',
'GL_COMPRESSED_ALPHA', 'GL_COMPRESSED_LUMINANCE',
'GL_COMPRESSED_LUMINANCE_ALPHA', 'GL_COMPRESSED_INTENSITY', 'GL_COMBINE',
'GL_COMBINE_RGB', 'GL_COMBINE_ALPHA', 'GL_SOURCE0_RGB', 'GL_SOURCE1_RGB',
'GL_SOURCE2_RGB', 'GL_SOURCE0_ALPHA', 'GL_SOURCE1_ALPHA', 'GL_SOURCE2_ALPHA',
'GL_OPERAND0_RGB', 'GL_OPERAND1_RGB', 'GL_OPERAND2_RGB', 'GL_OPERAND0_ALPHA',
'GL_OPERAND1_ALPHA', 'GL_OPERAND2_ALPHA', 'GL_RGB_SCALE', 'GL_ADD_SIGNED',
'GL_INTERPOLATE', 'GL_SUBTRACT', 'GL_CONSTANT', 'GL_PRIMARY_COLOR',
'GL_PREVIOUS', 'GL_DOT3_RGB', 'GL_DOT3_RGBA', 'GL_BLEND_DST_RGB',
'GL_BLEND_SRC_RGB', 'GL_BLEND_DST_ALPHA', 'GL_BLEND_SRC_ALPHA',
'GL_POINT_FADE_THRESHOLD_SIZE', 'GL_DEPTH_COMPONENT16',
'GL_DEPTH_COMPONENT24', 'GL_DEPTH_COMPONENT32', 'GL_MIRRORED_REPEAT',
'GL_MAX_TEXTURE_LOD_BIAS', 'GL_TEXTURE_LOD_BIAS', 'GL_INCR_WRAP',
'GL_DECR_WRAP', 'GL_TEXTURE_DEPTH_SIZE', 'GL_TEXTURE_COMPARE_MODE',
'GL_TEXTURE_COMPARE_FUNC', 'GL_POINT_SIZE_MIN', 'GL_POINT_SIZE_MAX',
'GL_POINT_DISTANCE_ATTENUATION', 'GL_GENERATE_MIPMAP',
'GL_GENERATE_MIPMAP_HINT', 'GL_FOG_COORDINATE_SOURCE', 'GL_FOG_COORDINATE',
'GL_FRAGMENT_DEPTH', 'GL_CURRENT_FOG_COORDINATE',
'GL_FOG_COORDINATE_ARRAY_TYPE', 'GL_FOG_COORDINATE_ARRAY_STRIDE',
'GL_FOG_COORDINATE_ARRAY_POINTER', 'GL_FOG_COORDINATE_ARRAY', 'GL_COLOR_SUM',
'GL_CURRENT_SECONDARY_COLOR', 'GL_SECONDARY_COLOR_ARRAY_SIZE',
'GL_SECONDARY_COLOR_ARRAY_TYPE', 'GL_SECONDARY_COLOR_ARRAY_STRIDE',
'GL_SECONDARY_COLOR_ARRAY_POINTER', 'GL_SECONDARY_COLOR_ARRAY',
'GL_TEXTURE_FILTER_CONTROL', 'GL_DEPTH_TEXTURE_MODE',
'GL_COMPARE_R_TO_TEXTURE', 'GL_BUFFER_SIZE', 'GL_BUFFER_USAGE',
'GL_QUERY_COUNTER_BITS', 'GL_CURRENT_QUERY', 'GL_QUERY_RESULT',
'GL_QUERY_RESULT_AVAILABLE', 'GL_ARRAY_BUFFER', 'GL_ELEMENT_ARRAY_BUFFER',
'GL_ARRAY_BUFFER_BINDING', 'GL_ELEMENT_ARRAY_BUFFER_BINDING',
'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING', 'GL_READ_ONLY', 'GL_WRITE_ONLY',
'GL_READ_WRITE', 'GL_BUFFER_ACCESS', 'GL_BUFFER_MAPPED',
'GL_BUFFER_MAP_POINTER', 'GL_STREAM_DRAW', 'GL_STREAM_READ', 'GL_STREAM_COPY',
'GL_STATIC_DRAW', 'GL_STATIC_READ', 'GL_STATIC_COPY', 'GL_DYNAMIC_DRAW',
'GL_DYNAMIC_READ', 'GL_DYNAMIC_COPY', 'GL_SAMPLES_PASSED',
'GL_VERTEX_ARRAY_BUFFER_BINDING', 'GL_NORMAL_ARRAY_BUFFER_BINDING',
'GL_COLOR_ARRAY_BUFFER_BINDING', 'GL_INDEX_ARRAY_BUFFER_BINDING',
'GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING', 'GL_EDGE_FLAG_ARRAY_BUFFER_BINDING',
'GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING',
'GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING', 'GL_WEIGHT_ARRAY_BUFFER_BINDING',
'GL_FOG_COORD_SRC', 'GL_FOG_COORD', 'GL_CURRENT_FOG_COORD',
'GL_FOG_COORD_ARRAY_TYPE', 'GL_FOG_COORD_ARRAY_STRIDE',
'GL_FOG_COORD_ARRAY_POINTER', 'GL_FOG_COORD_ARRAY',
'GL_FOG_COORD_ARRAY_BUFFER_BINDING', 'GL_SRC0_RGB', 'GL_SRC1_RGB',
'GL_SRC2_RGB', 'GL_SRC0_ALPHA', 'GL_SRC1_ALPHA', 'GL_SRC2_ALPHA',
'GL_BLEND_EQUATION_RGB', 'GL_VERTEX_ATTRIB_ARRAY_ENABLED',
'GL_VERTEX_ATTRIB_ARRAY_SIZE', 'GL_VERTEX_ATTRIB_ARRAY_STRIDE',
'GL_VERTEX_ATTRIB_ARRAY_TYPE', 'GL_CURRENT_VERTEX_ATTRIB',
'GL_VERTEX_PROGRAM_POINT_SIZE', 'GL_VERTEX_ATTRIB_ARRAY_POINTER',
'GL_STENCIL_BACK_FUNC', 'GL_STENCIL_BACK_FAIL',
'GL_STENCIL_BACK_PASS_DEPTH_FAIL', 'GL_STENCIL_BACK_PASS_DEPTH_PASS',
'GL_MAX_DRAW_BUFFERS', 'GL_DRAW_BUFFER0', 'GL_DRAW_BUFFER1',
'GL_DRAW_BUFFER2', 'GL_DRAW_BUFFER3', 'GL_DRAW_BUFFER4', 'GL_DRAW_BUFFER5',
'GL_DRAW_BUFFER6', 'GL_DRAW_BUFFER7', 'GL_DRAW_BUFFER8', 'GL_DRAW_BUFFER9',
'GL_DRAW_BUFFER10', 'GL_DRAW_BUFFER11', 'GL_DRAW_BUFFER12',
'GL_DRAW_BUFFER13', 'GL_DRAW_BUFFER14', 'GL_DRAW_BUFFER15',
'GL_BLEND_EQUATION_ALPHA', 'GL_MAX_VERTEX_ATTRIBS',
'GL_VERTEX_ATTRIB_ARRAY_NORMALIZED', 'GL_MAX_TEXTURE_IMAGE_UNITS',
'GL_FRAGMENT_SHADER', 'GL_VERTEX_SHADER',
'GL_MAX_FRAGMENT_UNIFORM_COMPONENTS', 'GL_MAX_VERTEX_UNIFORM_COMPONENTS',
'GL_MAX_VARYING_FLOATS', 'GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS',
'GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS', 'GL_SHADER_TYPE', 'GL_FLOAT_VEC2',
'GL_FLOAT_VEC3', 'GL_FLOAT_VEC4', 'GL_INT_VEC2', 'GL_INT_VEC3', 'GL_INT_VEC4',
'GL_BOOL', 'GL_BOOL_VEC2', 'GL_BOOL_VEC3', 'GL_BOOL_VEC4', 'GL_FLOAT_MAT2',
'GL_FLOAT_MAT3', 'GL_FLOAT_MAT4', 'GL_SAMPLER_1D', 'GL_SAMPLER_2D',
'GL_SAMPLER_3D', 'GL_SAMPLER_CUBE', 'GL_SAMPLER_1D_SHADOW',
'GL_SAMPLER_2D_SHADOW', 'GL_DELETE_STATUS', 'GL_COMPILE_STATUS',
'GL_LINK_STATUS', 'GL_VALIDATE_STATUS', 'GL_INFO_LOG_LENGTH',
'GL_ATTACHED_SHADERS', 'GL_ACTIVE_UNIFORMS', 'GL_ACTIVE_UNIFORM_MAX_LENGTH',
'GL_SHADER_SOURCE_LENGTH', 'GL_ACTIVE_ATTRIBUTES',
'GL_ACTIVE_ATTRIBUTE_MAX_LENGTH', 'GL_FRAGMENT_SHADER_DERIVATIVE_HINT',
'GL_SHADING_LANGUAGE_VERSION', 'GL_CURRENT_PROGRAM',
'GL_POINT_SPRITE_COORD_ORIGIN', 'GL_LOWER_LEFT', 'GL_UPPER_LEFT',
'GL_STENCIL_BACK_REF', 'GL_STENCIL_BACK_VALUE_MASK',
'GL_STENCIL_BACK_WRITEMASK', 'GL_VERTEX_PROGRAM_TWO_SIDE', 'GL_POINT_SPRITE',
'GL_COORD_REPLACE', 'GL_MAX_TEXTURE_COORDS', 'GL_PIXEL_PACK_BUFFER',
'GL_PIXEL_UNPACK_BUFFER', 'GL_PIXEL_PACK_BUFFER_BINDING',
'GL_PIXEL_UNPACK_BUFFER_BINDING', 'GL_FLOAT_MAT2x3', 'GL_FLOAT_MAT2x4',
'GL_FLOAT_MAT3x2', 'GL_FLOAT_MAT3x4', 'GL_FLOAT_MAT4x2', 'GL_FLOAT_MAT4x3',
'GL_SRGB', 'GL_SRGB8', 'GL_SRGB_ALPHA', 'GL_SRGB8_ALPHA8',
'GL_COMPRESSED_SRGB', 'GL_COMPRESSED_SRGB_ALPHA',
'GL_CURRENT_RASTER_SECONDARY_COLOR', 'GL_SLUMINANCE_ALPHA',
'GL_SLUMINANCE8_ALPHA8', 'GL_SLUMINANCE', 'GL_SLUMINANCE8',
'GL_COMPRESSED_SLUMINANCE', 'GL_COMPRESSED_SLUMINANCE_ALPHA',
'GL_COMPARE_REF_TO_TEXTURE', 'GL_CLIP_DISTANCE0', 'GL_CLIP_DISTANCE1',
'GL_CLIP_DISTANCE2', 'GL_CLIP_DISTANCE3', 'GL_CLIP_DISTANCE4',
'GL_CLIP_DISTANCE5', 'GL_CLIP_DISTANCE6', 'GL_CLIP_DISTANCE7',
'GL_MAX_CLIP_DISTANCES', 'GL_MAJOR_VERSION', 'GL_MINOR_VERSION',
'GL_NUM_EXTENSIONS', 'GL_CONTEXT_FLAGS', 'GL_COMPRESSED_RED',
'GL_COMPRESSED_RG', 'GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT', 'GL_RGBA32F',
'GL_RGB32F', 'GL_RGBA16F', 'GL_RGB16F', 'GL_VERTEX_ATTRIB_ARRAY_INTEGER',
'GL_MAX_ARRAY_TEXTURE_LAYERS', 'GL_MIN_PROGRAM_TEXEL_OFFSET',
'GL_MAX_PROGRAM_TEXEL_OFFSET', 'GL_CLAMP_READ_COLOR', 'GL_FIXED_ONLY',
'GL_MAX_VARYING_COMPONENTS', 'GL_TEXTURE_1D_ARRAY',
'GL_PROXY_TEXTURE_1D_ARRAY', 'GL_TEXTURE_2D_ARRAY',
'GL_PROXY_TEXTURE_2D_ARRAY', 'GL_TEXTURE_BINDING_1D_ARRAY',
'GL_TEXTURE_BINDING_2D_ARRAY', 'GL_R11F_G11F_B10F',
'GL_UNSIGNED_INT_10F_11F_11F_REV', 'GL_RGB9_E5',
'GL_UNSIGNED_INT_5_9_9_9_REV', 'GL_TEXTURE_SHARED_SIZE',
'GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH',
'GL_TRANSFORM_FEEDBACK_BUFFER_MODE',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS',
'GL_TRANSFORM_FEEDBACK_VARYINGS', 'GL_TRANSFORM_FEEDBACK_BUFFER_START',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE', 'GL_PRIMITIVES_GENERATED',
'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN', 'GL_RASTERIZER_DISCARD',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS', 'GL_INTERLEAVED_ATTRIBS',
'GL_SEPARATE_ATTRIBS', 'GL_TRANSFORM_FEEDBACK_BUFFER',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING', 'GL_RGBA32UI', 'GL_RGB32UI',
'GL_RGBA16UI', 'GL_RGB16UI', 'GL_RGBA8UI', 'GL_RGB8UI', 'GL_RGBA32I',
'GL_RGB32I', 'GL_RGBA16I', 'GL_RGB16I', 'GL_RGBA8I', 'GL_RGB8I',
'GL_RED_INTEGER', 'GL_GREEN_INTEGER', 'GL_BLUE_INTEGER', 'GL_RGB_INTEGER',
'GL_RGBA_INTEGER', 'GL_BGR_INTEGER', 'GL_BGRA_INTEGER', 'GL_SAMPLER_1D_ARRAY',
'GL_SAMPLER_2D_ARRAY', 'GL_SAMPLER_1D_ARRAY_SHADOW',
'GL_SAMPLER_2D_ARRAY_SHADOW', 'GL_SAMPLER_CUBE_SHADOW',
'GL_UNSIGNED_INT_VEC2', 'GL_UNSIGNED_INT_VEC3', 'GL_UNSIGNED_INT_VEC4',
'GL_INT_SAMPLER_1D', 'GL_INT_SAMPLER_2D', 'GL_INT_SAMPLER_3D',
'GL_INT_SAMPLER_CUBE', 'GL_INT_SAMPLER_1D_ARRAY', 'GL_INT_SAMPLER_2D_ARRAY',
'GL_UNSIGNED_INT_SAMPLER_1D', 'GL_UNSIGNED_INT_SAMPLER_2D',
'GL_UNSIGNED_INT_SAMPLER_3D', 'GL_UNSIGNED_INT_SAMPLER_CUBE',
'GL_UNSIGNED_INT_SAMPLER_1D_ARRAY', 'GL_UNSIGNED_INT_SAMPLER_2D_ARRAY',
'GL_QUERY_WAIT', 'GL_QUERY_NO_WAIT', 'GL_QUERY_BY_REGION_WAIT',
'GL_QUERY_BY_REGION_NO_WAIT', 'GL_BUFFER_ACCESS_FLAGS',
'GL_BUFFER_MAP_LENGTH', 'GL_BUFFER_MAP_OFFSET', 'GL_CLAMP_VERTEX_COLOR',
'GL_CLAMP_FRAGMENT_COLOR', 'GL_ALPHA_INTEGER', 'GL_SAMPLER_2D_RECT',
'GL_SAMPLER_2D_RECT_SHADOW', 'GL_SAMPLER_BUFFER', 'GL_INT_SAMPLER_2D_RECT',
'GL_INT_SAMPLER_BUFFER', 'GL_UNSIGNED_INT_SAMPLER_2D_RECT',
'GL_UNSIGNED_INT_SAMPLER_BUFFER', 'GL_TEXTURE_BUFFER',
'GL_MAX_TEXTURE_BUFFER_SIZE', 'GL_TEXTURE_BINDING_BUFFER',
'GL_TEXTURE_BUFFER_DATA_STORE_BINDING', 'GL_TEXTURE_BUFFER_FORMAT',
'GL_TEXTURE_RECTANGLE', 'GL_TEXTURE_BINDING_RECTANGLE',
'GL_PROXY_TEXTURE_RECTANGLE', 'GL_MAX_RECTANGLE_TEXTURE_SIZE', 'GL_RED_SNORM',
'GL_RG_SNORM', 'GL_RGB_SNORM', 'GL_RGBA_SNORM', 'GL_R8_SNORM', 'GL_RG8_SNORM',
'GL_RGB8_SNORM', 'GL_RGBA8_SNORM', 'GL_R16_SNORM', 'GL_RG16_SNORM',
'GL_RGB16_SNORM', 'GL_RGBA16_SNORM', 'GL_SIGNED_NORMALIZED',
'GL_PRIMITIVE_RESTART', 'GL_PRIMITIVE_RESTART_INDEX',
'GL_CONTEXT_CORE_PROFILE_BIT', 'GL_CONTEXT_COMPATIBILITY_PROFILE_BIT',
'GL_LINES_ADJACENCY', 'GL_LINE_STRIP_ADJACENCY', 'GL_TRIANGLES_ADJACENCY',
'GL_TRIANGLE_STRIP_ADJACENCY', 'GL_PROGRAM_POINT_SIZE',
'GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS', 'GL_FRAMEBUFFER_ATTACHMENT_LAYERED',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS', 'GL_GEOMETRY_SHADER',
'GL_GEOMETRY_VERTICES_OUT', 'GL_GEOMETRY_INPUT_TYPE',
'GL_GEOMETRY_OUTPUT_TYPE', 'GL_MAX_GEOMETRY_UNIFORM_COMPONENTS',
'GL_MAX_GEOMETRY_OUTPUT_VERTICES', 'GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS',
'GL_MAX_VERTEX_OUTPUT_COMPONENTS', 'GL_MAX_GEOMETRY_INPUT_COMPONENTS',
'GL_MAX_GEOMETRY_OUTPUT_COMPONENTS', 'GL_MAX_FRAGMENT_INPUT_COMPONENTS',
'GL_CONTEXT_PROFILE_MASK', 'GL_VERTEX_ATTRIB_ARRAY_DIVISOR',
'GL_SAMPLE_SHADING', 'GL_MIN_SAMPLE_SHADING_VALUE',
'GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET',
'GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET', 'GL_TEXTURE_CUBE_MAP_ARRAY',
'GL_TEXTURE_BINDING_CUBE_MAP_ARRAY', 'GL_PROXY_TEXTURE_CUBE_MAP_ARRAY',
'GL_SAMPLER_CUBE_MAP_ARRAY', 'GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW',
'GL_INT_SAMPLER_CUBE_MAP_ARRAY', 'GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY',
'GL_TRANSPOSE_MODELVIEW_MATRIX_ARB', 'GL_TRANSPOSE_PROJECTION_MATRIX_ARB',
'GL_TRANSPOSE_TEXTURE_MATRIX_ARB', 'GL_TRANSPOSE_COLOR_MATRIX_ARB',
'GL_MULTISAMPLE_ARB', 'GL_SAMPLE_ALPHA_TO_COVERAGE_ARB',
'GL_SAMPLE_ALPHA_TO_ONE_ARB', 'GL_SAMPLE_COVERAGE_ARB',
'GL_SAMPLE_BUFFERS_ARB', 'GL_SAMPLES_ARB', 'GL_SAMPLE_COVERAGE_VALUE_ARB',
'GL_SAMPLE_COVERAGE_INVERT_ARB', 'GL_MULTISAMPLE_BIT_ARB',
'GL_NORMAL_MAP_ARB', 'GL_REFLECTION_MAP_ARB', 'GL_TEXTURE_CUBE_MAP_ARB',
'GL_TEXTURE_BINDING_CUBE_MAP_ARB', 'GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB', 'GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB', 'GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB',
'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB', 'GL_PROXY_TEXTURE_CUBE_MAP_ARB',
'GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB', 'GL_COMPRESSED_ALPHA_ARB',
'GL_COMPRESSED_LUMINANCE_ARB', 'GL_COMPRESSED_LUMINANCE_ALPHA_ARB',
'GL_COMPRESSED_INTENSITY_ARB', 'GL_COMPRESSED_RGB_ARB',
'GL_COMPRESSED_RGBA_ARB', 'GL_TEXTURE_COMPRESSION_HINT_ARB',
'GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB', 'GL_TEXTURE_COMPRESSED_ARB',
'GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB', 'GL_COMPRESSED_TEXTURE_FORMATS_ARB',
'GL_CLAMP_TO_BORDER_ARB', 'GL_POINT_SIZE_MIN_ARB', 'GL_POINT_SIZE_MAX_ARB',
'GL_POINT_FADE_THRESHOLD_SIZE_ARB', 'GL_POINT_DISTANCE_ATTENUATION_ARB',
'GL_MAX_VERTEX_UNITS_ARB', 'GL_ACTIVE_VERTEX_UNITS_ARB',
'GL_WEIGHT_SUM_UNITY_ARB', 'GL_VERTEX_BLEND_ARB', 'GL_CURRENT_WEIGHT_ARB',
'GL_WEIGHT_ARRAY_TYPE_ARB', 'GL_WEIGHT_ARRAY_STRIDE_ARB',
'GL_WEIGHT_ARRAY_SIZE_ARB', 'GL_WEIGHT_ARRAY_POINTER_ARB',
'GL_WEIGHT_ARRAY_ARB', 'GL_MODELVIEW0_ARB', 'GL_MODELVIEW1_ARB',
'GL_MODELVIEW2_ARB', 'GL_MODELVIEW3_ARB', 'GL_MODELVIEW4_ARB',
'GL_MODELVIEW5_ARB', 'GL_MODELVIEW6_ARB', 'GL_MODELVIEW7_ARB',
'GL_MODELVIEW8_ARB', 'GL_MODELVIEW9_ARB', 'GL_MODELVIEW10_ARB',
'GL_MODELVIEW11_ARB', 'GL_MODELVIEW12_ARB', 'GL_MODELVIEW13_ARB',
'GL_MODELVIEW14_ARB', 'GL_MODELVIEW15_ARB', 'GL_MODELVIEW16_ARB',
'GL_MODELVIEW17_ARB', 'GL_MODELVIEW18_ARB', 'GL_MODELVIEW19_ARB',
'GL_MODELVIEW20_ARB', 'GL_MODELVIEW21_ARB', 'GL_MODELVIEW22_ARB',
'GL_MODELVIEW23_ARB', 'GL_MODELVIEW24_ARB', 'GL_MODELVIEW25_ARB',
'GL_MODELVIEW26_ARB', 'GL_MODELVIEW27_ARB', 'GL_MODELVIEW28_ARB',
'GL_MODELVIEW29_ARB', 'GL_MODELVIEW30_ARB', 'GL_MODELVIEW31_ARB',
'GL_MATRIX_PALETTE_ARB', 'GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB',
'GL_MAX_PALETTE_MATRICES_ARB', 'GL_CURRENT_PALETTE_MATRIX_ARB',
'GL_MATRIX_INDEX_ARRAY_ARB', 'GL_CURRENT_MATRIX_INDEX_ARB',
'GL_MATRIX_INDEX_ARRAY_SIZE_ARB', 'GL_MATRIX_INDEX_ARRAY_TYPE_ARB',
'GL_MATRIX_INDEX_ARRAY_STRIDE_ARB', 'GL_MATRIX_INDEX_ARRAY_POINTER_ARB',
'GL_COMBINE_ARB', 'GL_COMBINE_RGB_ARB', 'GL_COMBINE_ALPHA_ARB',
'GL_SOURCE0_RGB_ARB', 'GL_SOURCE1_RGB_ARB', 'GL_SOURCE2_RGB_ARB',
'GL_SOURCE0_ALPHA_ARB', 'GL_SOURCE1_ALPHA_ARB', 'GL_SOURCE2_ALPHA_ARB',
'GL_OPERAND0_RGB_ARB', 'GL_OPERAND1_RGB_ARB', 'GL_OPERAND2_RGB_ARB',
'GL_OPERAND0_ALPHA_ARB', 'GL_OPERAND1_ALPHA_ARB', 'GL_OPERAND2_ALPHA_ARB',
'GL_RGB_SCALE_ARB', 'GL_ADD_SIGNED_ARB', 'GL_INTERPOLATE_ARB',
'GL_SUBTRACT_ARB', 'GL_CONSTANT_ARB', 'GL_PRIMARY_COLOR_ARB',
'GL_PREVIOUS_ARB', 'GL_DOT3_RGB_ARB', 'GL_DOT3_RGBA_ARB',
'GL_MIRRORED_REPEAT_ARB', 'GL_DEPTH_COMPONENT16_ARB',
'GL_DEPTH_COMPONENT24_ARB', 'GL_DEPTH_COMPONENT32_ARB',
'GL_TEXTURE_DEPTH_SIZE_ARB', 'GL_DEPTH_TEXTURE_MODE_ARB',
'GL_TEXTURE_COMPARE_MODE_ARB', 'GL_TEXTURE_COMPARE_FUNC_ARB',
'GL_COMPARE_R_TO_TEXTURE_ARB', 'GL_TEXTURE_COMPARE_FAIL_VALUE_ARB',
'GL_COLOR_SUM_ARB', 'GL_VERTEX_PROGRAM_ARB',
'GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB', 'GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB',
'GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB', 'GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB',
'GL_CURRENT_VERTEX_ATTRIB_ARB', 'GL_PROGRAM_LENGTH_ARB',
'GL_PROGRAM_STRING_ARB', 'GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB',
'GL_MAX_PROGRAM_MATRICES_ARB', 'GL_CURRENT_MATRIX_STACK_DEPTH_ARB',
'GL_CURRENT_MATRIX_ARB', 'GL_VERTEX_PROGRAM_POINT_SIZE_ARB',
'GL_VERTEX_PROGRAM_TWO_SIDE_ARB', 'GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB',
'GL_PROGRAM_ERROR_POSITION_ARB', 'GL_PROGRAM_BINDING_ARB',
'GL_MAX_VERTEX_ATTRIBS_ARB', 'GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB',
'GL_PROGRAM_ERROR_STRING_ARB', 'GL_PROGRAM_FORMAT_ASCII_ARB',
'GL_PROGRAM_FORMAT_ARB', 'GL_PROGRAM_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_INSTRUCTIONS_ARB', 'GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB', 'GL_PROGRAM_TEMPORARIES_ARB',
'GL_MAX_PROGRAM_TEMPORARIES_ARB', 'GL_PROGRAM_NATIVE_TEMPORARIES_ARB',
'GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB', 'GL_PROGRAM_PARAMETERS_ARB',
'GL_MAX_PROGRAM_PARAMETERS_ARB', 'GL_PROGRAM_NATIVE_PARAMETERS_ARB',
'GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB', 'GL_PROGRAM_ATTRIBS_ARB',
'GL_MAX_PROGRAM_ATTRIBS_ARB', 'GL_PROGRAM_NATIVE_ATTRIBS_ARB',
'GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB', 'GL_PROGRAM_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB',
'GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',
'GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB', 'GL_MAX_PROGRAM_ENV_PARAMETERS_ARB',
'GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB', 'GL_TRANSPOSE_CURRENT_MATRIX_ARB',
'GL_MATRIX0_ARB', 'GL_MATRIX1_ARB', 'GL_MATRIX2_ARB', 'GL_MATRIX3_ARB',
'GL_MATRIX4_ARB', 'GL_MATRIX5_ARB', 'GL_MATRIX6_ARB', 'GL_MATRIX7_ARB',
'GL_MATRIX8_ARB', 'GL_MATRIX9_ARB', 'GL_MATRIX10_ARB', 'GL_MATRIX11_ARB',
'GL_MATRIX12_ARB', 'GL_MATRIX13_ARB', 'GL_MATRIX14_ARB', 'GL_MATRIX15_ARB',
'GL_MATRIX16_ARB', 'GL_MATRIX17_ARB', 'GL_MATRIX18_ARB', 'GL_MATRIX19_ARB',
'GL_MATRIX20_ARB', 'GL_MATRIX21_ARB', 'GL_MATRIX22_ARB', 'GL_MATRIX23_ARB',
'GL_MATRIX24_ARB', 'GL_MATRIX25_ARB', 'GL_MATRIX26_ARB', 'GL_MATRIX27_ARB',
'GL_MATRIX28_ARB', 'GL_MATRIX29_ARB', 'GL_MATRIX30_ARB', 'GL_MATRIX31_ARB',
'GL_FRAGMENT_PROGRAM_ARB', 'GL_PROGRAM_ALU_INSTRUCTIONS_ARB',
'GL_PROGRAM_TEX_INSTRUCTIONS_ARB', 'GL_PROGRAM_TEX_INDIRECTIONS_ARB',
'GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',
'GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',
'GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB',
'GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB', 'GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',
'GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB', 'GL_MAX_TEXTURE_COORDS_ARB',
'GL_MAX_TEXTURE_IMAGE_UNITS_ARB', 'GL_BUFFER_SIZE_ARB', 'GL_BUFFER_USAGE_ARB',
'GL_ARRAY_BUFFER_ARB', 'GL_ELEMENT_ARRAY_BUFFER_ARB',
'GL_ARRAY_BUFFER_BINDING_ARB', 'GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB',
'GL_VERTEX_ARRAY_BUFFER_BINDING_ARB', 'GL_NORMAL_ARRAY_BUFFER_BINDING_ARB',
'GL_COLOR_ARRAY_BUFFER_BINDING_ARB', 'GL_INDEX_ARRAY_BUFFER_BINDING_ARB',
'GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB',
'GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB',
'GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB',
'GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB',
'GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB',
'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB', 'GL_READ_ONLY_ARB',
'GL_WRITE_ONLY_ARB', 'GL_READ_WRITE_ARB', 'GL_BUFFER_ACCESS_ARB',
'GL_BUFFER_MAPPED_ARB', 'GL_BUFFER_MAP_POINTER_ARB', 'GL_STREAM_DRAW_ARB',
'GL_STREAM_READ_ARB', 'GL_STREAM_COPY_ARB', 'GL_STATIC_DRAW_ARB',
'GL_STATIC_READ_ARB', 'GL_STATIC_COPY_ARB', 'GL_DYNAMIC_DRAW_ARB',
'GL_DYNAMIC_READ_ARB', 'GL_DYNAMIC_COPY_ARB', 'GL_QUERY_COUNTER_BITS_ARB',
'GL_CURRENT_QUERY_ARB', 'GL_QUERY_RESULT_ARB',
'GL_QUERY_RESULT_AVAILABLE_ARB', 'GL_SAMPLES_PASSED_ARB',
'GL_PROGRAM_OBJECT_ARB', 'GL_SHADER_OBJECT_ARB', 'GL_OBJECT_TYPE_ARB',
'GL_OBJECT_SUBTYPE_ARB', 'GL_FLOAT_VEC2_ARB', 'GL_FLOAT_VEC3_ARB',
'GL_FLOAT_VEC4_ARB', 'GL_INT_VEC2_ARB', 'GL_INT_VEC3_ARB', 'GL_INT_VEC4_ARB',
'GL_BOOL_ARB', 'GL_BOOL_VEC2_ARB', 'GL_BOOL_VEC3_ARB', 'GL_BOOL_VEC4_ARB',
'GL_FLOAT_MAT2_ARB', 'GL_FLOAT_MAT3_ARB', 'GL_FLOAT_MAT4_ARB',
'GL_SAMPLER_1D_ARB', 'GL_SAMPLER_2D_ARB', 'GL_SAMPLER_3D_ARB',
'GL_SAMPLER_CUBE_ARB', 'GL_SAMPLER_1D_SHADOW_ARB', 'GL_SAMPLER_2D_SHADOW_ARB',
'GL_SAMPLER_2D_RECT_ARB', 'GL_SAMPLER_2D_RECT_SHADOW_ARB',
'GL_OBJECT_DELETE_STATUS_ARB', 'GL_OBJECT_COMPILE_STATUS_ARB',
'GL_OBJECT_LINK_STATUS_ARB', 'GL_OBJECT_VALIDATE_STATUS_ARB',
'GL_OBJECT_INFO_LOG_LENGTH_ARB', 'GL_OBJECT_ATTACHED_OBJECTS_ARB',
'GL_OBJECT_ACTIVE_UNIFORMS_ARB', 'GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB',
'GL_OBJECT_SHADER_SOURCE_LENGTH_ARB', 'GL_VERTEX_SHADER_ARB',
'GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB', 'GL_MAX_VARYING_FLOATS_ARB',
'GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB',
'GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB', 'GL_OBJECT_ACTIVE_ATTRIBUTES_ARB',
'GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB', 'GL_FRAGMENT_SHADER_ARB',
'GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB',
'GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB', 'GL_SHADING_LANGUAGE_VERSION_ARB',
'GL_POINT_SPRITE_ARB', 'GL_COORD_REPLACE_ARB', 'GL_MAX_DRAW_BUFFERS_ARB',
'GL_DRAW_BUFFER0_ARB', 'GL_DRAW_BUFFER1_ARB', 'GL_DRAW_BUFFER2_ARB',
'GL_DRAW_BUFFER3_ARB', 'GL_DRAW_BUFFER4_ARB', 'GL_DRAW_BUFFER5_ARB',
'GL_DRAW_BUFFER6_ARB', 'GL_DRAW_BUFFER7_ARB', 'GL_DRAW_BUFFER8_ARB',
'GL_DRAW_BUFFER9_ARB', 'GL_DRAW_BUFFER10_ARB', 'GL_DRAW_BUFFER11_ARB',
'GL_DRAW_BUFFER12_ARB', 'GL_DRAW_BUFFER13_ARB', 'GL_DRAW_BUFFER14_ARB',
'GL_DRAW_BUFFER15_ARB', 'GL_TEXTURE_RECTANGLE_ARB',
'GL_TEXTURE_BINDING_RECTANGLE_ARB', 'GL_PROXY_TEXTURE_RECTANGLE_ARB',
'GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB', 'GL_RGBA_FLOAT_MODE_ARB',
'GL_CLAMP_VERTEX_COLOR_ARB', 'GL_CLAMP_FRAGMENT_COLOR_ARB',
'GL_CLAMP_READ_COLOR_ARB', 'GL_FIXED_ONLY_ARB', 'GL_HALF_FLOAT_ARB',
'GL_TEXTURE_RED_TYPE_ARB', 'GL_TEXTURE_GREEN_TYPE_ARB',
'GL_TEXTURE_BLUE_TYPE_ARB', 'GL_TEXTURE_ALPHA_TYPE_ARB',
'GL_TEXTURE_LUMINANCE_TYPE_ARB', 'GL_TEXTURE_INTENSITY_TYPE_ARB',
'GL_TEXTURE_DEPTH_TYPE_ARB', 'GL_UNSIGNED_NORMALIZED_ARB', 'GL_RGBA32F_ARB',
'GL_RGB32F_ARB', 'GL_ALPHA32F_ARB', 'GL_INTENSITY32F_ARB',
'GL_LUMINANCE32F_ARB', 'GL_LUMINANCE_ALPHA32F_ARB', 'GL_RGBA16F_ARB',
'GL_RGB16F_ARB', 'GL_ALPHA16F_ARB', 'GL_INTENSITY16F_ARB',
'GL_LUMINANCE16F_ARB', 'GL_LUMINANCE_ALPHA16F_ARB',
'GL_PIXEL_PACK_BUFFER_ARB', 'GL_PIXEL_UNPACK_BUFFER_ARB',
'GL_PIXEL_PACK_BUFFER_BINDING_ARB', 'GL_PIXEL_UNPACK_BUFFER_BINDING_ARB',
'GL_DEPTH_COMPONENT32F', 'GL_DEPTH32F_STENCIL8',
'GL_FLOAT_32_UNSIGNED_INT_24_8_REV', 'GL_INVALID_FRAMEBUFFER_OPERATION',
'GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING',
'GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE',
'GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE', 'GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE', 'GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE',
'GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE', 'GL_FRAMEBUFFER_DEFAULT',
'GL_FRAMEBUFFER_UNDEFINED', 'GL_DEPTH_STENCIL_ATTACHMENT',
'GL_MAX_RENDERBUFFER_SIZE', 'GL_DEPTH_STENCIL', 'GL_UNSIGNED_INT_24_8',
'GL_DEPTH24_STENCIL8', 'GL_TEXTURE_STENCIL_SIZE', 'GL_TEXTURE_RED_TYPE',
'GL_TEXTURE_GREEN_TYPE', 'GL_TEXTURE_BLUE_TYPE', 'GL_TEXTURE_ALPHA_TYPE',
'GL_TEXTURE_DEPTH_TYPE', 'GL_UNSIGNED_NORMALIZED', 'GL_FRAMEBUFFER_BINDING',
'GL_DRAW_FRAMEBUFFER_BINDING', 'GL_RENDERBUFFER_BINDING',
'GL_READ_FRAMEBUFFER', 'GL_DRAW_FRAMEBUFFER', 'GL_READ_FRAMEBUFFER_BINDING',
'GL_RENDERBUFFER_SAMPLES', 'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER', 'GL_FRAMEBUFFER_COMPLETE',
'GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT',
'GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',
'GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER',
'GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER', 'GL_FRAMEBUFFER_UNSUPPORTED',
'GL_MAX_COLOR_ATTACHMENTS', 'GL_COLOR_ATTACHMENT0', 'GL_COLOR_ATTACHMENT1',
'GL_COLOR_ATTACHMENT2', 'GL_COLOR_ATTACHMENT3', 'GL_COLOR_ATTACHMENT4',
'GL_COLOR_ATTACHMENT5', 'GL_COLOR_ATTACHMENT6', 'GL_COLOR_ATTACHMENT7',
'GL_COLOR_ATTACHMENT8', 'GL_COLOR_ATTACHMENT9', 'GL_COLOR_ATTACHMENT10',
'GL_COLOR_ATTACHMENT11', 'GL_COLOR_ATTACHMENT12', 'GL_COLOR_ATTACHMENT13',
'GL_COLOR_ATTACHMENT14', 'GL_COLOR_ATTACHMENT15', 'GL_DEPTH_ATTACHMENT',
'GL_STENCIL_ATTACHMENT', 'GL_FRAMEBUFFER', 'GL_RENDERBUFFER',
'GL_RENDERBUFFER_WIDTH', 'GL_RENDERBUFFER_HEIGHT',
'GL_RENDERBUFFER_INTERNAL_FORMAT', 'GL_STENCIL_INDEX1', 'GL_STENCIL_INDEX4',
'GL_STENCIL_INDEX8', 'GL_STENCIL_INDEX16', 'GL_RENDERBUFFER_RED_SIZE',
'GL_RENDERBUFFER_GREEN_SIZE', 'GL_RENDERBUFFER_BLUE_SIZE',
'GL_RENDERBUFFER_ALPHA_SIZE', 'GL_RENDERBUFFER_DEPTH_SIZE',
'GL_RENDERBUFFER_STENCIL_SIZE', 'GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE',
'GL_MAX_SAMPLES', 'GL_INDEX', 'GL_TEXTURE_LUMINANCE_TYPE',
'GL_TEXTURE_INTENSITY_TYPE', 'GL_FRAMEBUFFER_SRGB', 'GL_LINES_ADJACENCY_ARB',
'GL_LINE_STRIP_ADJACENCY_ARB', 'GL_TRIANGLES_ADJACENCY_ARB',
'GL_TRIANGLE_STRIP_ADJACENCY_ARB', 'GL_PROGRAM_POINT_SIZE_ARB',
'GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB',
'GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB', 'GL_GEOMETRY_SHADER_ARB',
'GL_GEOMETRY_VERTICES_OUT_ARB', 'GL_GEOMETRY_INPUT_TYPE_ARB',
'GL_GEOMETRY_OUTPUT_TYPE_ARB', 'GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB',
'GL_MAX_VERTEX_VARYING_COMPONENTS_ARB',
'GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB',
'GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB',
'GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB', 'GL_HALF_FLOAT',
'GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB', 'GL_MAP_READ_BIT', 'GL_MAP_WRITE_BIT',
'GL_MAP_INVALIDATE_RANGE_BIT', 'GL_MAP_INVALIDATE_BUFFER_BIT',
'GL_MAP_FLUSH_EXPLICIT_BIT', 'GL_MAP_UNSYNCHRONIZED_BIT',
'GL_TEXTURE_BUFFER_ARB', 'GL_MAX_TEXTURE_BUFFER_SIZE_ARB',
'GL_TEXTURE_BINDING_BUFFER_ARB', 'GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB',
'GL_TEXTURE_BUFFER_FORMAT_ARB', 'GL_COMPRESSED_RED_RGTC1',
'GL_COMPRESSED_SIGNED_RED_RGTC1', 'GL_COMPRESSED_RG_RGTC2',
'GL_COMPRESSED_SIGNED_RG_RGTC2', 'GL_RG', 'GL_RG_INTEGER', 'GL_R8', 'GL_R16',
'GL_RG8', 'GL_RG16', 'GL_R16F', 'GL_R32F', 'GL_RG16F', 'GL_RG32F', 'GL_R8I',
'GL_R8UI', 'GL_R16I', 'GL_R16UI', 'GL_R32I', 'GL_R32UI', 'GL_RG8I',
'GL_RG8UI', 'GL_RG16I', 'GL_RG16UI', 'GL_RG32I', 'GL_RG32UI',
'GL_VERTEX_ARRAY_BINDING', 'GL_UNIFORM_BUFFER', 'GL_UNIFORM_BUFFER_BINDING',
'GL_UNIFORM_BUFFER_START', 'GL_UNIFORM_BUFFER_SIZE',
'GL_MAX_VERTEX_UNIFORM_BLOCKS', 'GL_MAX_GEOMETRY_UNIFORM_BLOCKS',
'GL_MAX_FRAGMENT_UNIFORM_BLOCKS', 'GL_MAX_COMBINED_UNIFORM_BLOCKS',
'GL_MAX_UNIFORM_BUFFER_BINDINGS', 'GL_MAX_UNIFORM_BLOCK_SIZE',
'GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS',
'GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS',
'GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS',
'GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT',
'GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH', 'GL_ACTIVE_UNIFORM_BLOCKS',
'GL_UNIFORM_TYPE', 'GL_UNIFORM_SIZE', 'GL_UNIFORM_NAME_LENGTH',
'GL_UNIFORM_BLOCK_INDEX', 'GL_UNIFORM_OFFSET', 'GL_UNIFORM_ARRAY_STRIDE',
'GL_UNIFORM_MATRIX_STRIDE', 'GL_UNIFORM_IS_ROW_MAJOR',
'GL_UNIFORM_BLOCK_BINDING', 'GL_UNIFORM_BLOCK_DATA_SIZE',
'GL_UNIFORM_BLOCK_NAME_LENGTH', 'GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS',
'GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES',
'GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER',
'GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER',
'GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER', 'GL_INVALID_INDEX',
'GL_COPY_READ_BUFFER_BINDING', 'GL_COPY_READ_BUFFER',
'GL_COPY_WRITE_BUFFER_BINDING', 'GL_COPY_WRITE_BUFFER', 'GL_DEPTH_CLAMP',
'GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION', 'GL_FIRST_VERTEX_CONVENTION',
'GL_LAST_VERTEX_CONVENTION', 'GL_PROVOKING_VERTEX',
'GL_TEXTURE_CUBE_MAP_SEAMLESS', 'GL_MAX_SERVER_WAIT_TIMEOUT',
'GL_OBJECT_TYPE', 'GL_SYNC_CONDITION', 'GL_SYNC_STATUS', 'GL_SYNC_FLAGS',
'GL_SYNC_FENCE', 'GL_SYNC_GPU_COMMANDS_COMPLETE', 'GL_UNSIGNALED',
'GL_SIGNALED', 'GL_ALREADY_SIGNALED', 'GL_TIMEOUT_EXPIRED',
'GL_CONDITION_SATISFIED', 'GL_WAIT_FAILED', 'GL_SYNC_FLUSH_COMMANDS_BIT',
'GL_TIMEOUT_IGNORED', 'GL_SAMPLE_POSITION', 'GL_SAMPLE_MASK',
'GL_SAMPLE_MASK_VALUE', 'GL_MAX_SAMPLE_MASK_WORDS',
'GL_TEXTURE_2D_MULTISAMPLE', 'GL_PROXY_TEXTURE_2D_MULTISAMPLE',
'GL_TEXTURE_2D_MULTISAMPLE_ARRAY', 'GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY',
'GL_TEXTURE_BINDING_2D_MULTISAMPLE',
'GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY', 'GL_TEXTURE_SAMPLES',
'GL_TEXTURE_FIXED_SAMPLE_LOCATIONS', 'GL_SAMPLER_2D_MULTISAMPLE',
'GL_INT_SAMPLER_2D_MULTISAMPLE', 'GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE',
'GL_SAMPLER_2D_MULTISAMPLE_ARRAY', 'GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',
'GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',
'GL_MAX_COLOR_TEXTURE_SAMPLES', 'GL_MAX_DEPTH_TEXTURE_SAMPLES',
'GL_MAX_INTEGER_SAMPLES', 'GL_SAMPLE_SHADING_ARB',
'GL_MIN_SAMPLE_SHADING_VALUE_ARB', 'GL_TEXTURE_CUBE_MAP_ARRAY_ARB',
'GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB',
'GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB', 'GL_SAMPLER_CUBE_MAP_ARRAY_ARB',
'GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB', 'GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB',
'GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB',
'GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB',
'GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB', 'GL_SHADER_INCLUDE_ARB',
'GL_NAMED_STRING_LENGTH_ARB', 'GL_NAMED_STRING_TYPE_ARB',
'GL_COMPRESSED_RGBA_BPTC_UNORM_ARB',
'GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB',
'GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB',
'GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB', 'GL_SRC1_COLOR',
'GL_ONE_MINUS_SRC1_COLOR', 'GL_ONE_MINUS_SRC1_ALPHA',
'GL_MAX_DUAL_SOURCE_DRAW_BUFFERS', 'GL_ANY_SAMPLES_PASSED',
'GL_SAMPLER_BINDING', 'GL_RGB10_A2UI', 'GL_TEXTURE_SWIZZLE_R',
'GL_TEXTURE_SWIZZLE_G', 'GL_TEXTURE_SWIZZLE_B', 'GL_TEXTURE_SWIZZLE_A',
'GL_TEXTURE_SWIZZLE_RGBA', 'GL_TIME_ELAPSED', 'GL_TIMESTAMP',
'GL_INT_2_10_10_10_REV', 'GL_DRAW_INDIRECT_BUFFER',
'GL_DRAW_INDIRECT_BUFFER_BINDING', 'GL_GEOMETRY_SHADER_INVOCATIONS',
'GL_MAX_GEOMETRY_SHADER_INVOCATIONS', 'GL_MIN_FRAGMENT_INTERPOLATION_OFFSET',
'GL_MAX_FRAGMENT_INTERPOLATION_OFFSET',
'GL_FRAGMENT_INTERPOLATION_OFFSET_BITS', 'GL_DOUBLE_VEC2', 'GL_DOUBLE_VEC3',
'GL_DOUBLE_VEC4', 'GL_DOUBLE_MAT2', 'GL_DOUBLE_MAT3', 'GL_DOUBLE_MAT4',
'GL_DOUBLE_MAT2x3', 'GL_DOUBLE_MAT2x4', 'GL_DOUBLE_MAT3x2',
'GL_DOUBLE_MAT3x4', 'GL_DOUBLE_MAT4x2', 'GL_DOUBLE_MAT4x3',
'GL_ACTIVE_SUBROUTINES', 'GL_ACTIVE_SUBROUTINE_UNIFORMS',
'GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS', 'GL_ACTIVE_SUBROUTINE_MAX_LENGTH',
'GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH', 'GL_MAX_SUBROUTINES',
'GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS', 'GL_NUM_COMPATIBLE_SUBROUTINES',
'GL_COMPATIBLE_SUBROUTINES', 'GL_PATCHES', 'GL_PATCH_VERTICES',
'GL_PATCH_DEFAULT_INNER_LEVEL', 'GL_PATCH_DEFAULT_OUTER_LEVEL',
'GL_TESS_CONTROL_OUTPUT_VERTICES', 'GL_TESS_GEN_MODE', 'GL_TESS_GEN_SPACING',
'GL_TESS_GEN_VERTEX_ORDER', 'GL_TESS_GEN_POINT_MODE', 'GL_ISOLINES',
'GL_FRACTIONAL_ODD', 'GL_FRACTIONAL_EVEN', 'GL_MAX_PATCH_VERTICES',
'GL_MAX_TESS_GEN_LEVEL', 'GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS',
'GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS',
'GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS',
'GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS',
'GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS', 'GL_MAX_TESS_PATCH_COMPONENTS',
'GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS',
'GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS',
'GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS', 'GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS',
'GL_MAX_TESS_CONTROL_INPUT_COMPONENTS',
'GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS',
'GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS',
'GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS',
'GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER',
'GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER',
'GL_TESS_EVALUATION_SHADER', 'GL_TESS_CONTROL_SHADER',
'GL_TRANSFORM_FEEDBACK', 'GL_TRANSFORM_FEEDBACK_PAUSED',
'GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED', 'GL_TRANSFORM_FEEDBACK_ACTIVE',
'GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE', 'GL_TRANSFORM_FEEDBACK_BINDING',
'GL_MAX_TRANSFORM_FEEDBACK_BUFFERS', 'GL_MAX_VERTEX_STREAMS', 'GL_FIXED',
'GL_IMPLEMENTATION_COLOR_READ_TYPE', 'GL_IMPLEMENTATION_COLOR_READ_FORMAT',
'GL_LOW_FLOAT', 'GL_MEDIUM_FLOAT', 'GL_HIGH_FLOAT', 'GL_LOW_INT',
'GL_MEDIUM_INT', 'GL_HIGH_INT', 'GL_SHADER_COMPILER',
'GL_NUM_SHADER_BINARY_FORMATS', 'GL_MAX_VERTEX_UNIFORM_VECTORS',
'GL_MAX_VARYING_VECTORS', 'GL_MAX_FRAGMENT_UNIFORM_VECTORS', 'GL_RGB565',
'GL_PROGRAM_BINARY_RETRIEVABLE_HINT', 'GL_PROGRAM_BINARY_LENGTH',
'GL_NUM_PROGRAM_BINARY_FORMATS', 'GL_PROGRAM_BINARY_FORMATS',
'GL_VERTEX_SHADER_BIT', 'GL_FRAGMENT_SHADER_BIT', 'GL_GEOMETRY_SHADER_BIT',
'GL_TESS_CONTROL_SHADER_BIT', 'GL_TESS_EVALUATION_SHADER_BIT',
'GL_ALL_SHADER_BITS', 'GL_PROGRAM_SEPARABLE', 'GL_ACTIVE_PROGRAM',
'GL_PROGRAM_PIPELINE_BINDING', 'GL_MAX_VIEWPORTS',
'GL_VIEWPORT_SUBPIXEL_BITS', 'GL_VIEWPORT_BOUNDS_RANGE',
'GL_LAYER_PROVOKING_VERTEX', 'GL_VIEWPORT_INDEX_PROVOKING_VERTEX',
'GL_UNDEFINED_VERTEX', 'GL_SYNC_CL_EVENT_ARB',
'GL_SYNC_CL_EVENT_COMPLETE_ARB', 'GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB',
'GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB', 'GL_DEBUG_CALLBACK_FUNCTION_ARB',
'GL_DEBUG_CALLBACK_USER_PARAM_ARB', 'GL_DEBUG_SOURCE_API_ARB',
'GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB', 'GL_DEBUG_SOURCE_SHADER_COMPILER_ARB',
'GL_DEBUG_SOURCE_THIRD_PARTY_ARB', 'GL_DEBUG_SOURCE_APPLICATION_ARB',
'GL_DEBUG_SOURCE_OTHER_ARB', 'GL_DEBUG_TYPE_ERROR_ARB',
'GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB',
'GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB', 'GL_DEBUG_TYPE_PORTABILITY_ARB',
'GL_DEBUG_TYPE_PERFORMANCE_ARB', 'GL_DEBUG_TYPE_OTHER_ARB',
'GL_MAX_DEBUG_MESSAGE_LENGTH_ARB', 'GL_MAX_DEBUG_LOGGED_MESSAGES_ARB',
'GL_DEBUG_LOGGED_MESSAGES_ARB', 'GL_DEBUG_SEVERITY_HIGH_ARB',
'GL_DEBUG_SEVERITY_MEDIUM_ARB', 'GL_DEBUG_SEVERITY_LOW_ARB',
'GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB', 'GL_LOSE_CONTEXT_ON_RESET_ARB',
'GL_GUILTY_CONTEXT_RESET_ARB', 'GL_INNOCENT_CONTEXT_RESET_ARB',
'GL_UNKNOWN_CONTEXT_RESET_ARB', 'GL_RESET_NOTIFICATION_STRATEGY_ARB',
'GL_NO_RESET_NOTIFICATION_ARB', 'GL_UNPACK_COMPRESSED_BLOCK_WIDTH',
'GL_UNPACK_COMPRESSED_BLOCK_HEIGHT', 'GL_UNPACK_COMPRESSED_BLOCK_DEPTH',
'GL_UNPACK_COMPRESSED_BLOCK_SIZE', 'GL_PACK_COMPRESSED_BLOCK_WIDTH',
'GL_PACK_COMPRESSED_BLOCK_HEIGHT', 'GL_PACK_COMPRESSED_BLOCK_DEPTH',
'GL_PACK_COMPRESSED_BLOCK_SIZE', 'GL_NUM_SAMPLE_COUNTS',
'GL_MIN_MAP_BUFFER_ALIGNMENT', 'GL_ATOMIC_COUNTER_BUFFER',
'GL_ATOMIC_COUNTER_BUFFER_BINDING', 'GL_ATOMIC_COUNTER_BUFFER_START',
'GL_ATOMIC_COUNTER_BUFFER_SIZE', 'GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE',
'GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS',
'GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES',
'GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER',
'GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER',
'GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER',
'GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER',
'GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER',
'GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS',
'GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS',
'GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS',
'GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS',
'GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS',
'GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS', 'GL_MAX_VERTEX_ATOMIC_COUNTERS',
'GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS',
'GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS', 'GL_MAX_GEOMETRY_ATOMIC_COUNTERS',
'GL_MAX_FRAGMENT_ATOMIC_COUNTERS', 'GL_MAX_COMBINED_ATOMIC_COUNTERS',
'GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE', 'GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS',
'GL_ACTIVE_ATOMIC_COUNTER_BUFFERS', 'GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX',
'GL_UNSIGNED_INT_ATOMIC_COUNTER', 'GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT',
'GL_ELEMENT_ARRAY_BARRIER_BIT', 'GL_UNIFORM_BARRIER_BIT',
'GL_TEXTURE_FETCH_BARRIER_BIT', 'GL_SHADER_IMAGE_ACCESS_BARRIER_BIT',
'GL_COMMAND_BARRIER_BIT', 'GL_PIXEL_BUFFER_BARRIER_BIT',
'GL_TEXTURE_UPDATE_BARRIER_BIT', 'GL_BUFFER_UPDATE_BARRIER_BIT',
'GL_FRAMEBUFFER_BARRIER_BIT', 'GL_TRANSFORM_FEEDBACK_BARRIER_BIT',
'GL_ATOMIC_COUNTER_BARRIER_BIT', 'GL_ALL_BARRIER_BITS', 'GL_MAX_IMAGE_UNITS',
'GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS', 'GL_IMAGE_BINDING_NAME',
'GL_IMAGE_BINDING_LEVEL', 'GL_IMAGE_BINDING_LAYERED',
'GL_IMAGE_BINDING_LAYER', 'GL_IMAGE_BINDING_ACCESS', 'GL_IMAGE_1D',
'GL_IMAGE_2D', 'GL_IMAGE_3D', 'GL_IMAGE_2D_RECT', 'GL_IMAGE_CUBE',
'GL_IMAGE_BUFFER', 'GL_IMAGE_1D_ARRAY', 'GL_IMAGE_2D_ARRAY',
'GL_IMAGE_CUBE_MAP_ARRAY', 'GL_IMAGE_2D_MULTISAMPLE',
'GL_IMAGE_2D_MULTISAMPLE_ARRAY', 'GL_INT_IMAGE_1D', 'GL_INT_IMAGE_2D',
'GL_INT_IMAGE_3D', 'GL_INT_IMAGE_2D_RECT', 'GL_INT_IMAGE_CUBE',
'GL_INT_IMAGE_BUFFER', 'GL_INT_IMAGE_1D_ARRAY', 'GL_INT_IMAGE_2D_ARRAY',
'GL_INT_IMAGE_CUBE_MAP_ARRAY', 'GL_INT_IMAGE_2D_MULTISAMPLE',
'GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY', 'GL_UNSIGNED_INT_IMAGE_1D',
'GL_UNSIGNED_INT_IMAGE_2D', 'GL_UNSIGNED_INT_IMAGE_3D',
'GL_UNSIGNED_INT_IMAGE_2D_RECT', 'GL_UNSIGNED_INT_IMAGE_CUBE',
'GL_UNSIGNED_INT_IMAGE_BUFFER', 'GL_UNSIGNED_INT_IMAGE_1D_ARRAY',
'GL_UNSIGNED_INT_IMAGE_2D_ARRAY', 'GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY',
'GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE',
'GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY', 'GL_MAX_IMAGE_SAMPLES',
'GL_IMAGE_BINDING_FORMAT', 'GL_IMAGE_FORMAT_COMPATIBILITY_TYPE',
'GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE',
'GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS', 'GL_MAX_VERTEX_IMAGE_UNIFORMS',
'GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS', 'GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS',
'GL_MAX_GEOMETRY_IMAGE_UNIFORMS', 'GL_MAX_FRAGMENT_IMAGE_UNIFORMS',
'GL_MAX_COMBINED_IMAGE_UNIFORMS', 'GL_TEXTURE_IMMUTABLE_FORMAT',
'GL_ABGR_EXT', 'GL_CONSTANT_COLOR_EXT', 'GL_ONE_MINUS_CONSTANT_COLOR_EXT',
'GL_CONSTANT_ALPHA_EXT', 'GL_ONE_MINUS_CONSTANT_ALPHA_EXT',
'GL_BLEND_COLOR_EXT', 'GL_POLYGON_OFFSET_EXT', 'GL_POLYGON_OFFSET_FACTOR_EXT',
'GL_POLYGON_OFFSET_BIAS_EXT', 'GL_ALPHA4_EXT', 'GL_ALPHA8_EXT',
'GL_ALPHA12_EXT', 'GL_ALPHA16_EXT', 'GL_LUMINANCE4_EXT', 'GL_LUMINANCE8_EXT',
'GL_LUMINANCE12_EXT', 'GL_LUMINANCE16_EXT', 'GL_LUMINANCE4_ALPHA4_EXT',
'GL_LUMINANCE6_ALPHA2_EXT', 'GL_LUMINANCE8_ALPHA8_EXT',
'GL_LUMINANCE12_ALPHA4_EXT', 'GL_LUMINANCE12_ALPHA12_EXT',
'GL_LUMINANCE16_ALPHA16_EXT', 'GL_INTENSITY_EXT', 'GL_INTENSITY4_EXT',
'GL_INTENSITY8_EXT', 'GL_INTENSITY12_EXT', 'GL_INTENSITY16_EXT',
'GL_RGB2_EXT', 'GL_RGB4_EXT', 'GL_RGB5_EXT', 'GL_RGB8_EXT', 'GL_RGB10_EXT',
'GL_RGB12_EXT', 'GL_RGB16_EXT', 'GL_RGBA2_EXT', 'GL_RGBA4_EXT',
'GL_RGB5_A1_EXT', 'GL_RGBA8_EXT', 'GL_RGB10_A2_EXT', 'GL_RGBA12_EXT',
'GL_RGBA16_EXT', 'GL_TEXTURE_RED_SIZE_EXT', 'GL_TEXTURE_GREEN_SIZE_EXT',
'GL_TEXTURE_BLUE_SIZE_EXT', 'GL_TEXTURE_ALPHA_SIZE_EXT',
'GL_TEXTURE_LUMINANCE_SIZE_EXT', 'GL_TEXTURE_INTENSITY_SIZE_EXT',
'GL_REPLACE_EXT', 'GL_PROXY_TEXTURE_1D_EXT', 'GL_PROXY_TEXTURE_2D_EXT',
'GL_TEXTURE_TOO_LARGE_EXT', 'GL_PACK_SKIP_IMAGES_EXT',
'GL_PACK_IMAGE_HEIGHT_EXT', 'GL_UNPACK_SKIP_IMAGES_EXT',
'GL_UNPACK_IMAGE_HEIGHT_EXT', 'GL_TEXTURE_3D_EXT', 'GL_PROXY_TEXTURE_3D_EXT',
'GL_TEXTURE_DEPTH_EXT', 'GL_TEXTURE_WRAP_R_EXT', 'GL_MAX_3D_TEXTURE_SIZE_EXT',
'GL_FILTER4_SGIS', 'GL_TEXTURE_FILTER4_SIZE_SGIS', 'GL_HISTOGRAM_EXT',
'GL_PROXY_HISTOGRAM_EXT', 'GL_HISTOGRAM_WIDTH_EXT', 'GL_HISTOGRAM_FORMAT_EXT',
'GL_HISTOGRAM_RED_SIZE_EXT', 'GL_HISTOGRAM_GREEN_SIZE_EXT',
'GL_HISTOGRAM_BLUE_SIZE_EXT', 'GL_HISTOGRAM_ALPHA_SIZE_EXT',
'GL_HISTOGRAM_LUMINANCE_SIZE_EXT', 'GL_HISTOGRAM_SINK_EXT', 'GL_MINMAX_EXT',
'GL_MINMAX_FORMAT_EXT', 'GL_MINMAX_SINK_EXT', 'GL_TABLE_TOO_LARGE_EXT',
'GL_CONVOLUTION_1D_EXT', 'GL_CONVOLUTION_2D_EXT', 'GL_SEPARABLE_2D_EXT',
'GL_CONVOLUTION_BORDER_MODE_EXT', 'GL_CONVOLUTION_FILTER_SCALE_EXT',
'GL_CONVOLUTION_FILTER_BIAS_EXT', 'GL_REDUCE_EXT',
'GL_CONVOLUTION_FORMAT_EXT', 'GL_CONVOLUTION_WIDTH_EXT',
'GL_CONVOLUTION_HEIGHT_EXT', 'GL_MAX_CONVOLUTION_WIDTH_EXT',
'GL_MAX_CONVOLUTION_HEIGHT_EXT', 'GL_POST_CONVOLUTION_RED_SCALE_EXT',
'GL_POST_CONVOLUTION_GREEN_SCALE_EXT', 'GL_POST_CONVOLUTION_BLUE_SCALE_EXT',
'GL_POST_CONVOLUTION_ALPHA_SCALE_EXT', 'GL_POST_CONVOLUTION_RED_BIAS_EXT',
'GL_POST_CONVOLUTION_GREEN_BIAS_EXT', 'GL_POST_CONVOLUTION_BLUE_BIAS_EXT',
'GL_POST_CONVOLUTION_ALPHA_BIAS_EXT', 'GL_COLOR_MATRIX_SGI',
'GL_COLOR_MATRIX_STACK_DEPTH_SGI', 'GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI',
'GL_POST_COLOR_MATRIX_RED_SCALE_SGI', 'GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI',
'GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI', 'GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI',
'GL_POST_COLOR_MATRIX_RED_BIAS_SGI', 'GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI',
'GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI', 'GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI',
'GL_COLOR_TABLE_SGI', 'GL_POST_CONVOLUTION_COLOR_TABLE_SGI',
'GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI', 'GL_PROXY_COLOR_TABLE_SGI',
'GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI',
'GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI', 'GL_COLOR_TABLE_SCALE_SGI',
'GL_COLOR_TABLE_BIAS_SGI', 'GL_COLOR_TABLE_FORMAT_SGI',
'GL_COLOR_TABLE_WIDTH_SGI', 'GL_COLOR_TABLE_RED_SIZE_SGI',
'GL_COLOR_TABLE_GREEN_SIZE_SGI', 'GL_COLOR_TABLE_BLUE_SIZE_SGI',
'GL_COLOR_TABLE_ALPHA_SIZE_SGI', 'GL_COLOR_TABLE_LUMINANCE_SIZE_SGI',
'GL_COLOR_TABLE_INTENSITY_SIZE_SGI', 'GL_PIXEL_TEXTURE_SGIS',
'GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS', 'GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS',
'GL_PIXEL_GROUP_COLOR_SGIS', 'GL_PIXEL_TEX_GEN_SGIX',
'GL_PIXEL_TEX_GEN_MODE_SGIX', 'GL_PACK_SKIP_VOLUMES_SGIS',
'GL_PACK_IMAGE_DEPTH_SGIS', 'GL_UNPACK_SKIP_VOLUMES_SGIS',
'GL_UNPACK_IMAGE_DEPTH_SGIS', 'GL_TEXTURE_4D_SGIS',
'GL_PROXY_TEXTURE_4D_SGIS', 'GL_TEXTURE_4DSIZE_SGIS',
'GL_TEXTURE_WRAP_Q_SGIS', 'GL_MAX_4D_TEXTURE_SIZE_SGIS',
'GL_TEXTURE_4D_BINDING_SGIS', 'GL_TEXTURE_COLOR_TABLE_SGI',
'GL_PROXY_TEXTURE_COLOR_TABLE_SGI', 'GL_CMYK_EXT', 'GL_CMYKA_EXT',
'GL_PACK_CMYK_HINT_EXT', 'GL_UNPACK_CMYK_HINT_EXT', 'GL_TEXTURE_PRIORITY_EXT',
'GL_TEXTURE_RESIDENT_EXT', 'GL_TEXTURE_1D_BINDING_EXT',
'GL_TEXTURE_2D_BINDING_EXT', 'GL_TEXTURE_3D_BINDING_EXT',
'GL_DETAIL_TEXTURE_2D_SGIS', 'GL_DETAIL_TEXTURE_2D_BINDING_SGIS',
'GL_LINEAR_DETAIL_SGIS', 'GL_LINEAR_DETAIL_ALPHA_SGIS',
'GL_LINEAR_DETAIL_COLOR_SGIS', 'GL_DETAIL_TEXTURE_LEVEL_SGIS',
'GL_DETAIL_TEXTURE_MODE_SGIS', 'GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS',
'GL_LINEAR_SHARPEN_SGIS', 'GL_LINEAR_SHARPEN_ALPHA_SGIS',
'GL_LINEAR_SHARPEN_COLOR_SGIS', 'GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS',
'GL_UNSIGNED_BYTE_3_3_2_EXT', 'GL_UNSIGNED_SHORT_4_4_4_4_EXT',
'GL_UNSIGNED_SHORT_5_5_5_1_EXT', 'GL_UNSIGNED_INT_8_8_8_8_EXT',
'GL_UNSIGNED_INT_10_10_10_2_EXT', 'GL_TEXTURE_MIN_LOD_SGIS',
'GL_TEXTURE_MAX_LOD_SGIS', 'GL_TEXTURE_BASE_LEVEL_SGIS',
'GL_TEXTURE_MAX_LEVEL_SGIS', 'GL_MULTISAMPLE_SGIS',
'GL_SAMPLE_ALPHA_TO_MASK_SGIS', 'GL_SAMPLE_ALPHA_TO_ONE_SGIS',
'GL_SAMPLE_MASK_SGIS', 'GL_1PASS_SGIS', 'GL_2PASS_0_SGIS', 'GL_2PASS_1_SGIS',
'GL_4PASS_0_SGIS', 'GL_4PASS_1_SGIS', 'GL_4PASS_2_SGIS', 'GL_4PASS_3_SGIS',
'GL_SAMPLE_BUFFERS_SGIS', 'GL_SAMPLES_SGIS', 'GL_SAMPLE_MASK_VALUE_SGIS',
'GL_SAMPLE_MASK_INVERT_SGIS', 'GL_SAMPLE_PATTERN_SGIS',
'GL_RESCALE_NORMAL_EXT', 'GL_VERTEX_ARRAY_EXT', 'GL_NORMAL_ARRAY_EXT',
'GL_COLOR_ARRAY_EXT', 'GL_INDEX_ARRAY_EXT', 'GL_TEXTURE_COORD_ARRAY_EXT',
'GL_EDGE_FLAG_ARRAY_EXT', 'GL_VERTEX_ARRAY_SIZE_EXT',
'GL_VERTEX_ARRAY_TYPE_EXT', 'GL_VERTEX_ARRAY_STRIDE_EXT',
'GL_VERTEX_ARRAY_COUNT_EXT', 'GL_NORMAL_ARRAY_TYPE_EXT',
'GL_NORMAL_ARRAY_STRIDE_EXT', 'GL_NORMAL_ARRAY_COUNT_EXT',
'GL_COLOR_ARRAY_SIZE_EXT', 'GL_COLOR_ARRAY_TYPE_EXT',
'GL_COLOR_ARRAY_STRIDE_EXT', 'GL_COLOR_ARRAY_COUNT_EXT',
'GL_INDEX_ARRAY_TYPE_EXT', 'GL_INDEX_ARRAY_STRIDE_EXT',
'GL_INDEX_ARRAY_COUNT_EXT', 'GL_TEXTURE_COORD_ARRAY_SIZE_EXT',
'GL_TEXTURE_COORD_ARRAY_TYPE_EXT', 'GL_TEXTURE_COORD_ARRAY_STRIDE_EXT',
'GL_TEXTURE_COORD_ARRAY_COUNT_EXT', 'GL_EDGE_FLAG_ARRAY_STRIDE_EXT',
'GL_EDGE_FLAG_ARRAY_COUNT_EXT', 'GL_VERTEX_ARRAY_POINTER_EXT',
'GL_NORMAL_ARRAY_POINTER_EXT', 'GL_COLOR_ARRAY_POINTER_EXT',
'GL_INDEX_ARRAY_POINTER_EXT', 'GL_TEXTURE_COORD_ARRAY_POINTER_EXT',
'GL_EDGE_FLAG_ARRAY_POINTER_EXT', 'GL_GENERATE_MIPMAP_SGIS',
'GL_GENERATE_MIPMAP_HINT_SGIS', 'GL_LINEAR_CLIPMAP_LINEAR_SGIX',
'GL_TEXTURE_CLIPMAP_CENTER_SGIX', 'GL_TEXTURE_CLIPMAP_FRAME_SGIX',
'GL_TEXTURE_CLIPMAP_OFFSET_SGIX', 'GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX',
'GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX', 'GL_TEXTURE_CLIPMAP_DEPTH_SGIX',
'GL_MAX_CLIPMAP_DEPTH_SGIX', 'GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX',
'GL_NEAREST_CLIPMAP_NEAREST_SGIX', 'GL_NEAREST_CLIPMAP_LINEAR_SGIX',
'GL_LINEAR_CLIPMAP_NEAREST_SGIX', 'GL_TEXTURE_COMPARE_SGIX',
'GL_TEXTURE_COMPARE_OPERATOR_SGIX', 'GL_TEXTURE_LEQUAL_R_SGIX',
'GL_TEXTURE_GEQUAL_R_SGIX', 'GL_CLAMP_TO_EDGE_SGIS',
'GL_CLAMP_TO_BORDER_SGIS', 'GL_FUNC_ADD_EXT', 'GL_MIN_EXT', 'GL_MAX_EXT',
'GL_BLEND_EQUATION_EXT', 'GL_FUNC_SUBTRACT_EXT',
'GL_FUNC_REVERSE_SUBTRACT_EXT', 'GL_INTERLACE_SGIX',
'GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX', 'GL_PIXEL_TILE_CACHE_INCREMENT_SGIX',
'GL_PIXEL_TILE_WIDTH_SGIX', 'GL_PIXEL_TILE_HEIGHT_SGIX',
'GL_PIXEL_TILE_GRID_WIDTH_SGIX', 'GL_PIXEL_TILE_GRID_HEIGHT_SGIX',
'GL_PIXEL_TILE_GRID_DEPTH_SGIX', 'GL_PIXEL_TILE_CACHE_SIZE_SGIX',
'GL_DUAL_ALPHA4_SGIS', 'GL_DUAL_ALPHA8_SGIS', 'GL_DUAL_ALPHA12_SGIS',
'GL_DUAL_ALPHA16_SGIS', 'GL_DUAL_LUMINANCE4_SGIS', 'GL_DUAL_LUMINANCE8_SGIS',
'GL_DUAL_LUMINANCE12_SGIS', 'GL_DUAL_LUMINANCE16_SGIS',
'GL_DUAL_INTENSITY4_SGIS', 'GL_DUAL_INTENSITY8_SGIS',
'GL_DUAL_INTENSITY12_SGIS', 'GL_DUAL_INTENSITY16_SGIS',
'GL_DUAL_LUMINANCE_ALPHA4_SGIS', 'GL_DUAL_LUMINANCE_ALPHA8_SGIS',
'GL_QUAD_ALPHA4_SGIS', 'GL_QUAD_ALPHA8_SGIS', 'GL_QUAD_LUMINANCE4_SGIS',
'GL_QUAD_LUMINANCE8_SGIS', 'GL_QUAD_INTENSITY4_SGIS',
'GL_QUAD_INTENSITY8_SGIS', 'GL_DUAL_TEXTURE_SELECT_SGIS',
'GL_QUAD_TEXTURE_SELECT_SGIS', 'GL_SPRITE_SGIX', 'GL_SPRITE_MODE_SGIX',
'GL_SPRITE_AXIS_SGIX', 'GL_SPRITE_TRANSLATION_SGIX', 'GL_SPRITE_AXIAL_SGIX',
'GL_SPRITE_OBJECT_ALIGNED_SGIX', 'GL_SPRITE_EYE_ALIGNED_SGIX',
'GL_TEXTURE_MULTI_BUFFER_HINT_SGIX', 'GL_POINT_SIZE_MIN_EXT',
'GL_POINT_SIZE_MAX_EXT', 'GL_POINT_FADE_THRESHOLD_SIZE_EXT',
'GL_DISTANCE_ATTENUATION_EXT', 'GL_POINT_SIZE_MIN_SGIS',
'GL_POINT_SIZE_MAX_SGIS', 'GL_POINT_FADE_THRESHOLD_SIZE_SGIS',
'GL_DISTANCE_ATTENUATION_SGIS', 'GL_INSTRUMENT_BUFFER_POINTER_SGIX',
'GL_INSTRUMENT_MEASUREMENTS_SGIX', 'GL_POST_TEXTURE_FILTER_BIAS_SGIX',
'GL_POST_TEXTURE_FILTER_SCALE_SGIX', 'GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX',
'GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX', 'GL_FRAMEZOOM_SGIX',
'GL_FRAMEZOOM_FACTOR_SGIX', 'GL_MAX_FRAMEZOOM_FACTOR_SGIX',
'GL_TEXTURE_DEFORMATION_BIT_SGIX', 'GL_GEOMETRY_DEFORMATION_BIT_SGIX',
'GL_GEOMETRY_DEFORMATION_SGIX', 'GL_TEXTURE_DEFORMATION_SGIX',
'GL_DEFORMATIONS_MASK_SGIX', 'GL_MAX_DEFORMATION_ORDER_SGIX',
'GL_REFERENCE_PLANE_SGIX', 'GL_REFERENCE_PLANE_EQUATION_SGIX',
'GL_DEPTH_COMPONENT16_SGIX', 'GL_DEPTH_COMPONENT24_SGIX',
'GL_DEPTH_COMPONENT32_SGIX', 'GL_FOG_FUNC_SGIS', 'GL_FOG_FUNC_POINTS_SGIS',
'GL_MAX_FOG_FUNC_POINTS_SGIS', 'GL_FOG_OFFSET_SGIX',
'GL_FOG_OFFSET_VALUE_SGIX', 'GL_IMAGE_SCALE_X_HP', 'GL_IMAGE_SCALE_Y_HP',
'GL_IMAGE_TRANSLATE_X_HP', 'GL_IMAGE_TRANSLATE_Y_HP',
'GL_IMAGE_ROTATE_ANGLE_HP', 'GL_IMAGE_ROTATE_ORIGIN_X_HP',
'GL_IMAGE_ROTATE_ORIGIN_Y_HP', 'GL_IMAGE_MAG_FILTER_HP',
'GL_IMAGE_MIN_FILTER_HP', 'GL_IMAGE_CUBIC_WEIGHT_HP', 'GL_CUBIC_HP',
'GL_AVERAGE_HP', 'GL_IMAGE_TRANSFORM_2D_HP',
'GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP',
'GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP', 'GL_IGNORE_BORDER_HP',
'GL_CONSTANT_BORDER_HP', 'GL_REPLICATE_BORDER_HP',
'GL_CONVOLUTION_BORDER_COLOR_HP', 'GL_TEXTURE_ENV_BIAS_SGIX',
'GL_VERTEX_DATA_HINT_PGI', 'GL_VERTEX_CONSISTENT_HINT_PGI',
'GL_MATERIAL_SIDE_HINT_PGI', 'GL_MAX_VERTEX_HINT_PGI', 'GL_COLOR3_BIT_PGI',
'GL_COLOR4_BIT_PGI', 'GL_EDGEFLAG_BIT_PGI', 'GL_INDEX_BIT_PGI',
'GL_MAT_AMBIENT_BIT_PGI', 'GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI',
'GL_MAT_DIFFUSE_BIT_PGI', 'GL_MAT_EMISSION_BIT_PGI',
'GL_MAT_COLOR_INDEXES_BIT_PGI', 'GL_MAT_SHININESS_BIT_PGI',
'GL_MAT_SPECULAR_BIT_PGI', 'GL_NORMAL_BIT_PGI', 'GL_TEXCOORD1_BIT_PGI',
'GL_TEXCOORD2_BIT_PGI', 'GL_TEXCOORD3_BIT_PGI', 'GL_TEXCOORD4_BIT_PGI',
'GL_VERTEX23_BIT_PGI', 'GL_VERTEX4_BIT_PGI',
'GL_PREFER_DOUBLEBUFFER_HINT_PGI', 'GL_CONSERVE_MEMORY_HINT_PGI',
'GL_RECLAIM_MEMORY_HINT_PGI', 'GL_NATIVE_GRAPHICS_HANDLE_PGI',
'GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI', 'GL_NATIVE_GRAPHICS_END_HINT_PGI',
'GL_ALWAYS_FAST_HINT_PGI', 'GL_ALWAYS_SOFT_HINT_PGI',
'GL_ALLOW_DRAW_OBJ_HINT_PGI', 'GL_ALLOW_DRAW_WIN_HINT_PGI',
'GL_ALLOW_DRAW_FRG_HINT_PGI', 'GL_ALLOW_DRAW_MEM_HINT_PGI',
'GL_STRICT_DEPTHFUNC_HINT_PGI', 'GL_STRICT_LIGHTING_HINT_PGI',
'GL_STRICT_SCISSOR_HINT_PGI', 'GL_FULL_STIPPLE_HINT_PGI',
'GL_CLIP_NEAR_HINT_PGI', 'GL_CLIP_FAR_HINT_PGI', 'GL_WIDE_LINE_HINT_PGI',
'GL_BACK_NORMALS_HINT_PGI', 'GL_COLOR_INDEX1_EXT', 'GL_COLOR_INDEX2_EXT',
'GL_COLOR_INDEX4_EXT', 'GL_COLOR_INDEX8_EXT', 'GL_COLOR_INDEX12_EXT',
'GL_COLOR_INDEX16_EXT', 'GL_TEXTURE_INDEX_SIZE_EXT',
'GL_CLIP_VOLUME_CLIPPING_HINT_EXT', 'GL_LIST_PRIORITY_SGIX',
'GL_IR_INSTRUMENT1_SGIX', 'GL_CALLIGRAPHIC_FRAGMENT_SGIX',
'GL_TEXTURE_LOD_BIAS_S_SGIX', 'GL_TEXTURE_LOD_BIAS_T_SGIX',
'GL_TEXTURE_LOD_BIAS_R_SGIX', 'GL_SHADOW_AMBIENT_SGIX',
'GL_INDEX_MATERIAL_EXT', 'GL_INDEX_MATERIAL_PARAMETER_EXT',
'GL_INDEX_MATERIAL_FACE_EXT', 'GL_INDEX_TEST_EXT', 'GL_INDEX_TEST_FUNC_EXT',
'GL_INDEX_TEST_REF_EXT', 'GL_IUI_V2F_EXT', 'GL_IUI_V3F_EXT',
'GL_IUI_N3F_V2F_EXT', 'GL_IUI_N3F_V3F_EXT', 'GL_T2F_IUI_V2F_EXT',
'GL_T2F_IUI_V3F_EXT', 'GL_T2F_IUI_N3F_V2F_EXT', 'GL_T2F_IUI_N3F_V3F_EXT',
'GL_ARRAY_ELEMENT_LOCK_FIRST_EXT', 'GL_ARRAY_ELEMENT_LOCK_COUNT_EXT',
'GL_CULL_VERTEX_EXT', 'GL_CULL_VERTEX_EYE_POSITION_EXT',
'GL_CULL_VERTEX_OBJECT_POSITION_EXT', 'GL_YCRCB_422_SGIX',
'GL_YCRCB_444_SGIX', 'GL_FRAGMENT_LIGHTING_SGIX',
'GL_FRAGMENT_COLOR_MATERIAL_SGIX', 'GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX',
'GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX', 'GL_MAX_FRAGMENT_LIGHTS_SGIX',
'GL_MAX_ACTIVE_LIGHTS_SGIX', 'GL_CURRENT_RASTER_NORMAL_SGIX',
'GL_LIGHT_ENV_MODE_SGIX', 'GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX',
'GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX',
'GL_FRAGMENT_LIGHT0_SGIX', 'GL_FRAGMENT_LIGHT1_SGIX',
'GL_FRAGMENT_LIGHT2_SGIX', 'GL_FRAGMENT_LIGHT3_SGIX',
'GL_FRAGMENT_LIGHT4_SGIX', 'GL_FRAGMENT_LIGHT5_SGIX',
'GL_FRAGMENT_LIGHT6_SGIX', 'GL_FRAGMENT_LIGHT7_SGIX',
'GL_RASTER_POSITION_UNCLIPPED_IBM', 'GL_TEXTURE_LIGHTING_MODE_HP',
'GL_TEXTURE_POST_SPECULAR_HP', 'GL_TEXTURE_PRE_SPECULAR_HP',
'GL_MAX_ELEMENTS_VERTICES_EXT', 'GL_MAX_ELEMENTS_INDICES_EXT', 'GL_PHONG_WIN',
'GL_PHONG_HINT_WIN', 'GL_FOG_SPECULAR_TEXTURE_WIN',
'GL_FRAGMENT_MATERIAL_EXT', 'GL_FRAGMENT_NORMAL_EXT', 'GL_FRAGMENT_COLOR_EXT',
'GL_ATTENUATION_EXT', 'GL_SHADOW_ATTENUATION_EXT',
'GL_TEXTURE_APPLICATION_MODE_EXT', 'GL_TEXTURE_LIGHT_EXT',
'GL_TEXTURE_MATERIAL_FACE_EXT', 'GL_TEXTURE_MATERIAL_PARAMETER_EXT',
'GL_ALPHA_MIN_SGIX', 'GL_ALPHA_MAX_SGIX', 'GL_PIXEL_TEX_GEN_Q_CEILING_SGIX',
'GL_PIXEL_TEX_GEN_Q_ROUND_SGIX', 'GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX', 'GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX',
'GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX', 'GL_BGR_EXT', 'GL_BGRA_EXT',
'GL_ASYNC_MARKER_SGIX', 'GL_ASYNC_TEX_IMAGE_SGIX',
'GL_ASYNC_DRAW_PIXELS_SGIX', 'GL_ASYNC_READ_PIXELS_SGIX',
'GL_MAX_ASYNC_TEX_IMAGE_SGIX', 'GL_MAX_ASYNC_DRAW_PIXELS_SGIX',
'GL_MAX_ASYNC_READ_PIXELS_SGIX', 'GL_ASYNC_HISTOGRAM_SGIX',
'GL_MAX_ASYNC_HISTOGRAM_SGIX', 'GL_PARALLEL_ARRAYS_INTEL',
'GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL',
'GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL', 'GL_OCCLUSION_TEST_HP',
'GL_OCCLUSION_TEST_RESULT_HP', 'GL_PIXEL_TRANSFORM_2D_EXT',
'GL_PIXEL_MAG_FILTER_EXT', 'GL_PIXEL_MIN_FILTER_EXT',
'GL_PIXEL_CUBIC_WEIGHT_EXT', 'GL_CUBIC_EXT', 'GL_AVERAGE_EXT',
'GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',
'GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',
'GL_PIXEL_TRANSFORM_2D_MATRIX_EXT', 'GL_SHARED_TEXTURE_PALETTE_EXT',
'GL_LIGHT_MODEL_COLOR_CONTROL_EXT', 'GL_SINGLE_COLOR_EXT',
'GL_SEPARATE_SPECULAR_COLOR_EXT', 'GL_COLOR_SUM_EXT',
'GL_CURRENT_SECONDARY_COLOR_EXT', 'GL_SECONDARY_COLOR_ARRAY_SIZE_EXT',
'GL_SECONDARY_COLOR_ARRAY_TYPE_EXT', 'GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT',
'GL_SECONDARY_COLOR_ARRAY_POINTER_EXT', 'GL_SECONDARY_COLOR_ARRAY_EXT',
'GL_PERTURB_EXT', 'GL_TEXTURE_NORMAL_EXT', 'GL_FOG_COORDINATE_SOURCE_EXT',
'GL_FOG_COORDINATE_EXT', 'GL_FRAGMENT_DEPTH_EXT',
'GL_CURRENT_FOG_COORDINATE_EXT', 'GL_FOG_COORDINATE_ARRAY_TYPE_EXT',
'GL_FOG_COORDINATE_ARRAY_STRIDE_EXT', 'GL_FOG_COORDINATE_ARRAY_POINTER_EXT',
'GL_FOG_COORDINATE_ARRAY_EXT', 'GL_SCREEN_COORDINATES_REND',
'GL_INVERTED_SCREEN_W_REND', 'GL_TANGENT_ARRAY_EXT', 'GL_BINORMAL_ARRAY_EXT',
'GL_CURRENT_TANGENT_EXT', 'GL_CURRENT_BINORMAL_EXT',
'GL_TANGENT_ARRAY_TYPE_EXT', 'GL_TANGENT_ARRAY_STRIDE_EXT',
'GL_BINORMAL_ARRAY_TYPE_EXT', 'GL_BINORMAL_ARRAY_STRIDE_EXT',
'GL_TANGENT_ARRAY_POINTER_EXT', 'GL_BINORMAL_ARRAY_POINTER_EXT',
'GL_MAP1_TANGENT_EXT', 'GL_MAP2_TANGENT_EXT', 'GL_MAP1_BINORMAL_EXT',
'GL_MAP2_BINORMAL_EXT', 'GL_COMBINE_EXT', 'GL_COMBINE_RGB_EXT',
'GL_COMBINE_ALPHA_EXT', 'GL_RGB_SCALE_EXT', 'GL_ADD_SIGNED_EXT',
'GL_INTERPOLATE_EXT', 'GL_CONSTANT_EXT', 'GL_PRIMARY_COLOR_EXT',
'GL_PREVIOUS_EXT', 'GL_SOURCE0_RGB_EXT', 'GL_SOURCE1_RGB_EXT',
'GL_SOURCE2_RGB_EXT', 'GL_SOURCE0_ALPHA_EXT', 'GL_SOURCE1_ALPHA_EXT',
'GL_SOURCE2_ALPHA_EXT', 'GL_OPERAND0_RGB_EXT', 'GL_OPERAND1_RGB_EXT',
'GL_OPERAND2_RGB_EXT', 'GL_OPERAND0_ALPHA_EXT', 'GL_OPERAND1_ALPHA_EXT',
'GL_OPERAND2_ALPHA_EXT', 'GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE',
'GL_TRANSFORM_HINT_APPLE', 'GL_FOG_SCALE_SGIX', 'GL_FOG_SCALE_VALUE_SGIX',
'GL_UNPACK_CONSTANT_DATA_SUNX', 'GL_TEXTURE_CONSTANT_DATA_SUNX',
'GL_GLOBAL_ALPHA_SUN', 'GL_GLOBAL_ALPHA_FACTOR_SUN', 'GL_RESTART_SUN',
'GL_REPLACE_MIDDLE_SUN', 'GL_REPLACE_OLDEST_SUN', 'GL_TRIANGLE_LIST_SUN',
'GL_REPLACEMENT_CODE_SUN', 'GL_REPLACEMENT_CODE_ARRAY_SUN',
'GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN', 'GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN',
'GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN', 'GL_R1UI_V3F_SUN',
'GL_R1UI_C4UB_V3F_SUN', 'GL_R1UI_C3F_V3F_SUN', 'GL_R1UI_N3F_V3F_SUN',
'GL_R1UI_C4F_N3F_V3F_SUN', 'GL_R1UI_T2F_V3F_SUN', 'GL_R1UI_T2F_N3F_V3F_SUN',
'GL_R1UI_T2F_C4F_N3F_V3F_SUN', 'GL_BLEND_DST_RGB_EXT', 'GL_BLEND_SRC_RGB_EXT',
'GL_BLEND_DST_ALPHA_EXT', 'GL_BLEND_SRC_ALPHA_EXT', 'GL_RED_MIN_CLAMP_INGR',
'GL_GREEN_MIN_CLAMP_INGR', 'GL_BLUE_MIN_CLAMP_INGR',
'GL_ALPHA_MIN_CLAMP_INGR', 'GL_RED_MAX_CLAMP_INGR', 'GL_GREEN_MAX_CLAMP_INGR',
'GL_BLUE_MAX_CLAMP_INGR', 'GL_ALPHA_MAX_CLAMP_INGR', 'GL_INTERLACE_READ_INGR',
'GL_INCR_WRAP_EXT', 'GL_DECR_WRAP_EXT', 'GL_422_EXT', 'GL_422_REV_EXT',
'GL_422_AVERAGE_EXT', 'GL_422_REV_AVERAGE_EXT', 'GL_NORMAL_MAP_NV',
'GL_REFLECTION_MAP_NV', 'GL_NORMAL_MAP_EXT', 'GL_REFLECTION_MAP_EXT',
'GL_TEXTURE_CUBE_MAP_EXT', 'GL_TEXTURE_BINDING_CUBE_MAP_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT',
'GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT', 'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT',
'GL_PROXY_TEXTURE_CUBE_MAP_EXT', 'GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT',
'GL_WRAP_BORDER_SUN', 'GL_MAX_TEXTURE_LOD_BIAS_EXT',
'GL_TEXTURE_FILTER_CONTROL_EXT', 'GL_TEXTURE_LOD_BIAS_EXT',
'GL_TEXTURE_MAX_ANISOTROPY_EXT', 'GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT',
'GL_MODELVIEW0_STACK_DEPTH_EXT', 'GL_MODELVIEW1_STACK_DEPTH_EXT',
'GL_MODELVIEW0_MATRIX_EXT', 'GL_MODELVIEW1_MATRIX_EXT',
'GL_VERTEX_WEIGHTING_EXT', 'GL_MODELVIEW0_EXT', 'GL_MODELVIEW1_EXT',
'GL_CURRENT_VERTEX_WEIGHT_EXT', 'GL_VERTEX_WEIGHT_ARRAY_EXT',
'GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT', 'GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT',
'GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT', 'GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT',
'GL_MAX_SHININESS_NV', 'GL_MAX_SPOT_EXPONENT_NV', 'GL_VERTEX_ARRAY_RANGE_NV',
'GL_VERTEX_ARRAY_RANGE_LENGTH_NV', 'GL_VERTEX_ARRAY_RANGE_VALID_NV',
'GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV', 'GL_VERTEX_ARRAY_RANGE_POINTER_NV',
'GL_REGISTER_COMBINERS_NV', 'GL_VARIABLE_A_NV', 'GL_VARIABLE_B_NV',
'GL_VARIABLE_C_NV', 'GL_VARIABLE_D_NV', 'GL_VARIABLE_E_NV',
'GL_VARIABLE_F_NV', 'GL_VARIABLE_G_NV', 'GL_CONSTANT_COLOR0_NV',
'GL_CONSTANT_COLOR1_NV', 'GL_PRIMARY_COLOR_NV', 'GL_SECONDARY_COLOR_NV',
'GL_SPARE0_NV', 'GL_SPARE1_NV', 'GL_DISCARD_NV', 'GL_E_TIMES_F_NV',
'GL_SPARE0_PLUS_SECONDARY_COLOR_NV', 'GL_UNSIGNED_IDENTITY_NV',
'GL_UNSIGNED_INVERT_NV', 'GL_EXPAND_NORMAL_NV', 'GL_EXPAND_NEGATE_NV',
'GL_HALF_BIAS_NORMAL_NV', 'GL_HALF_BIAS_NEGATE_NV', 'GL_SIGNED_IDENTITY_NV',
'GL_SIGNED_NEGATE_NV', 'GL_SCALE_BY_TWO_NV', 'GL_SCALE_BY_FOUR_NV',
'GL_SCALE_BY_ONE_HALF_NV', 'GL_BIAS_BY_NEGATIVE_ONE_HALF_NV',
'GL_COMBINER_INPUT_NV', 'GL_COMBINER_MAPPING_NV',
'GL_COMBINER_COMPONENT_USAGE_NV', 'GL_COMBINER_AB_DOT_PRODUCT_NV',
'GL_COMBINER_CD_DOT_PRODUCT_NV', 'GL_COMBINER_MUX_SUM_NV',
'GL_COMBINER_SCALE_NV', 'GL_COMBINER_BIAS_NV', 'GL_COMBINER_AB_OUTPUT_NV',
'GL_COMBINER_CD_OUTPUT_NV', 'GL_COMBINER_SUM_OUTPUT_NV',
'GL_MAX_GENERAL_COMBINERS_NV', 'GL_NUM_GENERAL_COMBINERS_NV',
'GL_COLOR_SUM_CLAMP_NV', 'GL_COMBINER0_NV', 'GL_COMBINER1_NV',
'GL_COMBINER2_NV', 'GL_COMBINER3_NV', 'GL_COMBINER4_NV', 'GL_COMBINER5_NV',
'GL_COMBINER6_NV', 'GL_COMBINER7_NV', 'GL_FOG_DISTANCE_MODE_NV',
'GL_EYE_RADIAL_NV', 'GL_EYE_PLANE_ABSOLUTE_NV', 'GL_EMBOSS_LIGHT_NV',
'GL_EMBOSS_CONSTANT_NV', 'GL_EMBOSS_MAP_NV', 'GL_COMBINE4_NV',
'GL_SOURCE3_RGB_NV', 'GL_SOURCE3_ALPHA_NV', 'GL_OPERAND3_RGB_NV',
'GL_OPERAND3_ALPHA_NV', 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT',
'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT', 'GL_COMPRESSED_RGBA_S3TC_DXT3_EXT',
'GL_COMPRESSED_RGBA_S3TC_DXT5_EXT', 'GL_CULL_VERTEX_IBM',
'GL_VERTEX_ARRAY_LIST_IBM', 'GL_NORMAL_ARRAY_LIST_IBM',
'GL_COLOR_ARRAY_LIST_IBM', 'GL_INDEX_ARRAY_LIST_IBM',
'GL_TEXTURE_COORD_ARRAY_LIST_IBM', 'GL_EDGE_FLAG_ARRAY_LIST_IBM',
'GL_FOG_COORDINATE_ARRAY_LIST_IBM', 'GL_SECONDARY_COLOR_ARRAY_LIST_IBM',
'GL_VERTEX_ARRAY_LIST_STRIDE_IBM', 'GL_NORMAL_ARRAY_LIST_STRIDE_IBM',
'GL_COLOR_ARRAY_LIST_STRIDE_IBM', 'GL_INDEX_ARRAY_LIST_STRIDE_IBM',
'GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM',
'GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM',
'GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM',
'GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM', 'GL_PACK_SUBSAMPLE_RATE_SGIX',
'GL_UNPACK_SUBSAMPLE_RATE_SGIX', 'GL_PIXEL_SUBSAMPLE_4444_SGIX',
'GL_PIXEL_SUBSAMPLE_2424_SGIX', 'GL_PIXEL_SUBSAMPLE_4242_SGIX',
'GL_YCRCB_SGIX', 'GL_YCRCBA_SGIX', 'GL_DEPTH_PASS_INSTRUMENT_SGIX',
'GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX', 'GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX',
'GL_COMPRESSED_RGB_FXT1_3DFX', 'GL_COMPRESSED_RGBA_FXT1_3DFX',
'GL_MULTISAMPLE_3DFX', 'GL_SAMPLE_BUFFERS_3DFX', 'GL_SAMPLES_3DFX',
'GL_MULTISAMPLE_BIT_3DFX', 'GL_MULTISAMPLE_EXT',
'GL_SAMPLE_ALPHA_TO_MASK_EXT', 'GL_SAMPLE_ALPHA_TO_ONE_EXT',
'GL_SAMPLE_MASK_EXT', 'GL_1PASS_EXT', 'GL_2PASS_0_EXT', 'GL_2PASS_1_EXT',
'GL_4PASS_0_EXT', 'GL_4PASS_1_EXT', 'GL_4PASS_2_EXT', 'GL_4PASS_3_EXT',
'GL_SAMPLE_BUFFERS_EXT', 'GL_SAMPLES_EXT', 'GL_SAMPLE_MASK_VALUE_EXT',
'GL_SAMPLE_MASK_INVERT_EXT', 'GL_SAMPLE_PATTERN_EXT',
'GL_MULTISAMPLE_BIT_EXT', 'GL_VERTEX_PRECLIP_SGIX',
'GL_VERTEX_PRECLIP_HINT_SGIX', 'GL_CONVOLUTION_HINT_SGIX',
'GL_PACK_RESAMPLE_SGIX', 'GL_UNPACK_RESAMPLE_SGIX',
'GL_RESAMPLE_REPLICATE_SGIX', 'GL_RESAMPLE_ZERO_FILL_SGIX',
'GL_RESAMPLE_DECIMATE_SGIX', 'GL_EYE_DISTANCE_TO_POINT_SGIS',
'GL_OBJECT_DISTANCE_TO_POINT_SGIS', 'GL_EYE_DISTANCE_TO_LINE_SGIS',
'GL_OBJECT_DISTANCE_TO_LINE_SGIS', 'GL_EYE_POINT_SGIS',
'GL_OBJECT_POINT_SGIS', 'GL_EYE_LINE_SGIS', 'GL_OBJECT_LINE_SGIS',
'GL_TEXTURE_COLOR_WRITEMASK_SGIS', 'GL_DOT3_RGB_EXT', 'GL_DOT3_RGBA_EXT',
'GL_MIRROR_CLAMP_ATI', 'GL_MIRROR_CLAMP_TO_EDGE_ATI', 'GL_ALL_COMPLETED_NV',
'GL_FENCE_STATUS_NV', 'GL_FENCE_CONDITION_NV', 'GL_MIRRORED_REPEAT_IBM',
'GL_EVAL_2D_NV', 'GL_EVAL_TRIANGULAR_2D_NV', 'GL_MAP_TESSELLATION_NV',
'GL_MAP_ATTRIB_U_ORDER_NV', 'GL_MAP_ATTRIB_V_ORDER_NV',
'GL_EVAL_FRACTIONAL_TESSELLATION_NV', 'GL_EVAL_VERTEX_ATTRIB0_NV',
'GL_EVAL_VERTEX_ATTRIB1_NV', 'GL_EVAL_VERTEX_ATTRIB2_NV',
'GL_EVAL_VERTEX_ATTRIB3_NV', 'GL_EVAL_VERTEX_ATTRIB4_NV',
'GL_EVAL_VERTEX_ATTRIB5_NV', 'GL_EVAL_VERTEX_ATTRIB6_NV',
'GL_EVAL_VERTEX_ATTRIB7_NV', 'GL_EVAL_VERTEX_ATTRIB8_NV',
'GL_EVAL_VERTEX_ATTRIB9_NV', 'GL_EVAL_VERTEX_ATTRIB10_NV',
'GL_EVAL_VERTEX_ATTRIB11_NV', 'GL_EVAL_VERTEX_ATTRIB12_NV',
'GL_EVAL_VERTEX_ATTRIB13_NV', 'GL_EVAL_VERTEX_ATTRIB14_NV',
'GL_EVAL_VERTEX_ATTRIB15_NV', 'GL_MAX_MAP_TESSELLATION_NV',
'GL_MAX_RATIONAL_EVAL_ORDER_NV', 'GL_DEPTH_STENCIL_NV',
'GL_UNSIGNED_INT_24_8_NV', 'GL_PER_STAGE_CONSTANTS_NV',
'GL_TEXTURE_RECTANGLE_NV', 'GL_TEXTURE_BINDING_RECTANGLE_NV',
'GL_PROXY_TEXTURE_RECTANGLE_NV', 'GL_MAX_RECTANGLE_TEXTURE_SIZE_NV',
'GL_OFFSET_TEXTURE_RECTANGLE_NV', 'GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV',
'GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV',
'GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV', 'GL_UNSIGNED_INT_S8_S8_8_8_NV',
'GL_UNSIGNED_INT_8_8_S8_S8_REV_NV', 'GL_DSDT_MAG_INTENSITY_NV',
'GL_SHADER_CONSISTENT_NV', 'GL_TEXTURE_SHADER_NV', 'GL_SHADER_OPERATION_NV',
'GL_CULL_MODES_NV', 'GL_OFFSET_TEXTURE_MATRIX_NV',
'GL_OFFSET_TEXTURE_SCALE_NV', 'GL_OFFSET_TEXTURE_BIAS_NV',
'GL_OFFSET_TEXTURE_2D_MATRIX_NV', 'GL_OFFSET_TEXTURE_2D_SCALE_NV',
'GL_OFFSET_TEXTURE_2D_BIAS_NV', 'GL_PREVIOUS_TEXTURE_INPUT_NV',
'GL_CONST_EYE_NV', 'GL_PASS_THROUGH_NV', 'GL_CULL_FRAGMENT_NV',
'GL_OFFSET_TEXTURE_2D_NV', 'GL_DEPENDENT_AR_TEXTURE_2D_NV',
'GL_DEPENDENT_GB_TEXTURE_2D_NV', 'GL_DOT_PRODUCT_NV',
'GL_DOT_PRODUCT_DEPTH_REPLACE_NV', 'GL_DOT_PRODUCT_TEXTURE_2D_NV',
'GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV', 'GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV',
'GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV',
'GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV', 'GL_HILO_NV', 'GL_DSDT_NV',
'GL_DSDT_MAG_NV', 'GL_DSDT_MAG_VIB_NV', 'GL_HILO16_NV', 'GL_SIGNED_HILO_NV',
'GL_SIGNED_HILO16_NV', 'GL_SIGNED_RGBA_NV', 'GL_SIGNED_RGBA8_NV',
'GL_SIGNED_RGB_NV', 'GL_SIGNED_RGB8_NV', 'GL_SIGNED_LUMINANCE_NV',
'GL_SIGNED_LUMINANCE8_NV', 'GL_SIGNED_LUMINANCE_ALPHA_NV',
'GL_SIGNED_LUMINANCE8_ALPHA8_NV', 'GL_SIGNED_ALPHA_NV', 'GL_SIGNED_ALPHA8_NV',
'GL_SIGNED_INTENSITY_NV', 'GL_SIGNED_INTENSITY8_NV', 'GL_DSDT8_NV',
'GL_DSDT8_MAG8_NV', 'GL_DSDT8_MAG8_INTENSITY8_NV',
'GL_SIGNED_RGB_UNSIGNED_ALPHA_NV', 'GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV',
'GL_HI_SCALE_NV', 'GL_LO_SCALE_NV', 'GL_DS_SCALE_NV', 'GL_DT_SCALE_NV',
'GL_MAGNITUDE_SCALE_NV', 'GL_VIBRANCE_SCALE_NV', 'GL_HI_BIAS_NV',
'GL_LO_BIAS_NV', 'GL_DS_BIAS_NV', 'GL_DT_BIAS_NV', 'GL_MAGNITUDE_BIAS_NV',
'GL_VIBRANCE_BIAS_NV', 'GL_TEXTURE_BORDER_VALUES_NV', 'GL_TEXTURE_HI_SIZE_NV',
'GL_TEXTURE_LO_SIZE_NV', 'GL_TEXTURE_DS_SIZE_NV', 'GL_TEXTURE_DT_SIZE_NV',
'GL_TEXTURE_MAG_SIZE_NV', 'GL_DOT_PRODUCT_TEXTURE_3D_NV',
'GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV', 'GL_VERTEX_PROGRAM_NV',
'GL_VERTEX_STATE_PROGRAM_NV', 'GL_ATTRIB_ARRAY_SIZE_NV',
'GL_ATTRIB_ARRAY_STRIDE_NV', 'GL_ATTRIB_ARRAY_TYPE_NV',
'GL_CURRENT_ATTRIB_NV', 'GL_PROGRAM_LENGTH_NV', 'GL_PROGRAM_STRING_NV',
'GL_MODELVIEW_PROJECTION_NV', 'GL_IDENTITY_NV', 'GL_INVERSE_NV',
'GL_TRANSPOSE_NV', 'GL_INVERSE_TRANSPOSE_NV',
'GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV', 'GL_MAX_TRACK_MATRICES_NV',
'GL_MATRIX0_NV', 'GL_MATRIX1_NV', 'GL_MATRIX2_NV', 'GL_MATRIX3_NV',
'GL_MATRIX4_NV', 'GL_MATRIX5_NV', 'GL_MATRIX6_NV', 'GL_MATRIX7_NV',
'GL_CURRENT_MATRIX_STACK_DEPTH_NV', 'GL_CURRENT_MATRIX_NV',
'GL_VERTEX_PROGRAM_POINT_SIZE_NV', 'GL_VERTEX_PROGRAM_TWO_SIDE_NV',
'GL_PROGRAM_PARAMETER_NV', 'GL_ATTRIB_ARRAY_POINTER_NV',
'GL_PROGRAM_TARGET_NV', 'GL_PROGRAM_RESIDENT_NV', 'GL_TRACK_MATRIX_NV',
'GL_TRACK_MATRIX_TRANSFORM_NV', 'GL_VERTEX_PROGRAM_BINDING_NV',
'GL_PROGRAM_ERROR_POSITION_NV', 'GL_VERTEX_ATTRIB_ARRAY0_NV',
'GL_VERTEX_ATTRIB_ARRAY1_NV', 'GL_VERTEX_ATTRIB_ARRAY2_NV',
'GL_VERTEX_ATTRIB_ARRAY3_NV', 'GL_VERTEX_ATTRIB_ARRAY4_NV',
'GL_VERTEX_ATTRIB_ARRAY5_NV', 'GL_VERTEX_ATTRIB_ARRAY6_NV',
'GL_VERTEX_ATTRIB_ARRAY7_NV', 'GL_VERTEX_ATTRIB_ARRAY8_NV',
'GL_VERTEX_ATTRIB_ARRAY9_NV', 'GL_VERTEX_ATTRIB_ARRAY10_NV',
'GL_VERTEX_ATTRIB_ARRAY11_NV', 'GL_VERTEX_ATTRIB_ARRAY12_NV',
'GL_VERTEX_ATTRIB_ARRAY13_NV', 'GL_VERTEX_ATTRIB_ARRAY14_NV',
'GL_VERTEX_ATTRIB_ARRAY15_NV', 'GL_MAP1_VERTEX_ATTRIB0_4_NV',
'GL_MAP1_VERTEX_ATTRIB1_4_NV', 'GL_MAP1_VERTEX_ATTRIB2_4_NV',
'GL_MAP1_VERTEX_ATTRIB3_4_NV', 'GL_MAP1_VERTEX_ATTRIB4_4_NV',
'GL_MAP1_VERTEX_ATTRIB5_4_NV', 'GL_MAP1_VERTEX_ATTRIB6_4_NV',
'GL_MAP1_VERTEX_ATTRIB7_4_NV', 'GL_MAP1_VERTEX_ATTRIB8_4_NV',
'GL_MAP1_VERTEX_ATTRIB9_4_NV', 'GL_MAP1_VERTEX_ATTRIB10_4_NV',
'GL_MAP1_VERTEX_ATTRIB11_4_NV', 'GL_MAP1_VERTEX_ATTRIB12_4_NV',
'GL_MAP1_VERTEX_ATTRIB13_4_NV', 'GL_MAP1_VERTEX_ATTRIB14_4_NV',
'GL_MAP1_VERTEX_ATTRIB15_4_NV', 'GL_MAP2_VERTEX_ATTRIB0_4_NV',
'GL_MAP2_VERTEX_ATTRIB1_4_NV', 'GL_MAP2_VERTEX_ATTRIB2_4_NV',
'GL_MAP2_VERTEX_ATTRIB3_4_NV', 'GL_MAP2_VERTEX_ATTRIB4_4_NV',
'GL_MAP2_VERTEX_ATTRIB5_4_NV', 'GL_MAP2_VERTEX_ATTRIB6_4_NV',
'GL_MAP2_VERTEX_ATTRIB7_4_NV', 'GL_MAP2_VERTEX_ATTRIB8_4_NV',
'GL_MAP2_VERTEX_ATTRIB9_4_NV', 'GL_MAP2_VERTEX_ATTRIB10_4_NV',
'GL_MAP2_VERTEX_ATTRIB11_4_NV', 'GL_MAP2_VERTEX_ATTRIB12_4_NV',
'GL_MAP2_VERTEX_ATTRIB13_4_NV', 'GL_MAP2_VERTEX_ATTRIB14_4_NV',
'GL_MAP2_VERTEX_ATTRIB15_4_NV', 'GL_TEXTURE_MAX_CLAMP_S_SGIX',
'GL_TEXTURE_MAX_CLAMP_T_SGIX', 'GL_TEXTURE_MAX_CLAMP_R_SGIX',
'GL_SCALEBIAS_HINT_SGIX', 'GL_INTERLACE_OML', 'GL_INTERLACE_READ_OML',
'GL_FORMAT_SUBSAMPLE_24_24_OML', 'GL_FORMAT_SUBSAMPLE_244_244_OML',
'GL_PACK_RESAMPLE_OML', 'GL_UNPACK_RESAMPLE_OML', 'GL_RESAMPLE_REPLICATE_OML',
'GL_RESAMPLE_ZERO_FILL_OML', 'GL_RESAMPLE_AVERAGE_OML',
'GL_RESAMPLE_DECIMATE_OML', 'GL_DEPTH_STENCIL_TO_RGBA_NV',
'GL_DEPTH_STENCIL_TO_BGRA_NV', 'GL_BUMP_ROT_MATRIX_ATI',
'GL_BUMP_ROT_MATRIX_SIZE_ATI', 'GL_BUMP_NUM_TEX_UNITS_ATI',
'GL_BUMP_TEX_UNITS_ATI', 'GL_DUDV_ATI', 'GL_DU8DV8_ATI', 'GL_BUMP_ENVMAP_ATI',
'GL_BUMP_TARGET_ATI', 'GL_FRAGMENT_SHADER_ATI', 'GL_REG_0_ATI',
'GL_REG_1_ATI', 'GL_REG_2_ATI', 'GL_REG_3_ATI', 'GL_REG_4_ATI',
'GL_REG_5_ATI', 'GL_REG_6_ATI', 'GL_REG_7_ATI', 'GL_REG_8_ATI',
'GL_REG_9_ATI', 'GL_REG_10_ATI', 'GL_REG_11_ATI', 'GL_REG_12_ATI',
'GL_REG_13_ATI', 'GL_REG_14_ATI', 'GL_REG_15_ATI', 'GL_REG_16_ATI',
'GL_REG_17_ATI', 'GL_REG_18_ATI', 'GL_REG_19_ATI', 'GL_REG_20_ATI',
'GL_REG_21_ATI', 'GL_REG_22_ATI', 'GL_REG_23_ATI', 'GL_REG_24_ATI',
'GL_REG_25_ATI', 'GL_REG_26_ATI', 'GL_REG_27_ATI', 'GL_REG_28_ATI',
'GL_REG_29_ATI', 'GL_REG_30_ATI', 'GL_REG_31_ATI', 'GL_CON_0_ATI',
'GL_CON_1_ATI', 'GL_CON_2_ATI', 'GL_CON_3_ATI', 'GL_CON_4_ATI',
'GL_CON_5_ATI', 'GL_CON_6_ATI', 'GL_CON_7_ATI', 'GL_CON_8_ATI',
'GL_CON_9_ATI', 'GL_CON_10_ATI', 'GL_CON_11_ATI', 'GL_CON_12_ATI',
'GL_CON_13_ATI', 'GL_CON_14_ATI', 'GL_CON_15_ATI', 'GL_CON_16_ATI',
'GL_CON_17_ATI', 'GL_CON_18_ATI', 'GL_CON_19_ATI', 'GL_CON_20_ATI',
'GL_CON_21_ATI', 'GL_CON_22_ATI', 'GL_CON_23_ATI', 'GL_CON_24_ATI',
'GL_CON_25_ATI', 'GL_CON_26_ATI', 'GL_CON_27_ATI', 'GL_CON_28_ATI',
'GL_CON_29_ATI', 'GL_CON_30_ATI', 'GL_CON_31_ATI', 'GL_MOV_ATI', 'GL_ADD_ATI',
'GL_MUL_ATI', 'GL_SUB_ATI', 'GL_DOT3_ATI', 'GL_DOT4_ATI', 'GL_MAD_ATI',
'GL_LERP_ATI', 'GL_CND_ATI', 'GL_CND0_ATI', 'GL_DOT2_ADD_ATI',
'GL_SECONDARY_INTERPOLATOR_ATI', 'GL_NUM_FRAGMENT_REGISTERS_ATI',
'GL_NUM_FRAGMENT_CONSTANTS_ATI', 'GL_NUM_PASSES_ATI',
'GL_NUM_INSTRUCTIONS_PER_PASS_ATI', 'GL_NUM_INSTRUCTIONS_TOTAL_ATI',
'GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI', 'GL_NUM_LOOPBACK_COMPONENTS_ATI',
'GL_COLOR_ALPHA_PAIRING_ATI', 'GL_SWIZZLE_STR_ATI', 'GL_SWIZZLE_STQ_ATI',
'GL_SWIZZLE_STR_DR_ATI', 'GL_SWIZZLE_STQ_DQ_ATI', 'GL_SWIZZLE_STRQ_ATI',
'GL_SWIZZLE_STRQ_DQ_ATI', 'GL_RED_BIT_ATI', 'GL_GREEN_BIT_ATI',
'GL_BLUE_BIT_ATI', 'GL_2X_BIT_ATI', 'GL_4X_BIT_ATI', 'GL_8X_BIT_ATI',
'GL_HALF_BIT_ATI', 'GL_QUARTER_BIT_ATI', 'GL_EIGHTH_BIT_ATI',
'GL_SATURATE_BIT_ATI', 'GL_COMP_BIT_ATI', 'GL_NEGATE_BIT_ATI',
'GL_BIAS_BIT_ATI', 'GL_PN_TRIANGLES_ATI',
'GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI', 'GL_PN_TRIANGLES_POINT_MODE_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_ATI', 'GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI',
'GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI',
'GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI',
'GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI', 'GL_STATIC_ATI',
'GL_DYNAMIC_ATI', 'GL_PRESERVE_ATI', 'GL_DISCARD_ATI',
'GL_OBJECT_BUFFER_SIZE_ATI', 'GL_OBJECT_BUFFER_USAGE_ATI',
'GL_ARRAY_OBJECT_BUFFER_ATI', 'GL_ARRAY_OBJECT_OFFSET_ATI',
'GL_VERTEX_SHADER_EXT', 'GL_VERTEX_SHADER_BINDING_EXT', 'GL_OP_INDEX_EXT',
'GL_OP_NEGATE_EXT', 'GL_OP_DOT3_EXT', 'GL_OP_DOT4_EXT', 'GL_OP_MUL_EXT',
'GL_OP_ADD_EXT', 'GL_OP_MADD_EXT', 'GL_OP_FRAC_EXT', 'GL_OP_MAX_EXT',
'GL_OP_MIN_EXT', 'GL_OP_SET_GE_EXT', 'GL_OP_SET_LT_EXT', 'GL_OP_CLAMP_EXT',
'GL_OP_FLOOR_EXT', 'GL_OP_ROUND_EXT', 'GL_OP_EXP_BASE_2_EXT',
'GL_OP_LOG_BASE_2_EXT', 'GL_OP_POWER_EXT', 'GL_OP_RECIP_EXT',
'GL_OP_RECIP_SQRT_EXT', 'GL_OP_SUB_EXT', 'GL_OP_CROSS_PRODUCT_EXT',
'GL_OP_MULTIPLY_MATRIX_EXT', 'GL_OP_MOV_EXT', 'GL_OUTPUT_VERTEX_EXT',
'GL_OUTPUT_COLOR0_EXT', 'GL_OUTPUT_COLOR1_EXT',
'GL_OUTPUT_TEXTURE_COORD0_EXT', 'GL_OUTPUT_TEXTURE_COORD1_EXT',
'GL_OUTPUT_TEXTURE_COORD2_EXT', 'GL_OUTPUT_TEXTURE_COORD3_EXT',
'GL_OUTPUT_TEXTURE_COORD4_EXT', 'GL_OUTPUT_TEXTURE_COORD5_EXT',
'GL_OUTPUT_TEXTURE_COORD6_EXT', 'GL_OUTPUT_TEXTURE_COORD7_EXT',
'GL_OUTPUT_TEXTURE_COORD8_EXT', 'GL_OUTPUT_TEXTURE_COORD9_EXT',
'GL_OUTPUT_TEXTURE_COORD10_EXT', 'GL_OUTPUT_TEXTURE_COORD11_EXT',
'GL_OUTPUT_TEXTURE_COORD12_EXT', 'GL_OUTPUT_TEXTURE_COORD13_EXT',
'GL_OUTPUT_TEXTURE_COORD14_EXT', 'GL_OUTPUT_TEXTURE_COORD15_EXT',
'GL_OUTPUT_TEXTURE_COORD16_EXT', 'GL_OUTPUT_TEXTURE_COORD17_EXT',
'GL_OUTPUT_TEXTURE_COORD18_EXT', 'GL_OUTPUT_TEXTURE_COORD19_EXT',
'GL_OUTPUT_TEXTURE_COORD20_EXT', 'GL_OUTPUT_TEXTURE_COORD21_EXT',
'GL_OUTPUT_TEXTURE_COORD22_EXT', 'GL_OUTPUT_TEXTURE_COORD23_EXT',
'GL_OUTPUT_TEXTURE_COORD24_EXT', 'GL_OUTPUT_TEXTURE_COORD25_EXT',
'GL_OUTPUT_TEXTURE_COORD26_EXT', 'GL_OUTPUT_TEXTURE_COORD27_EXT',
'GL_OUTPUT_TEXTURE_COORD28_EXT', 'GL_OUTPUT_TEXTURE_COORD29_EXT',
'GL_OUTPUT_TEXTURE_COORD30_EXT', 'GL_OUTPUT_TEXTURE_COORD31_EXT',
'GL_OUTPUT_FOG_EXT', 'GL_SCALAR_EXT', 'GL_VECTOR_EXT', 'GL_MATRIX_EXT',
'GL_VARIANT_EXT', 'GL_INVARIANT_EXT', 'GL_LOCAL_CONSTANT_EXT', 'GL_LOCAL_EXT',
'GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT', 'GL_MAX_VERTEX_SHADER_VARIANTS_EXT',
'GL_MAX_VERTEX_SHADER_INVARIANTS_EXT',
'GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT', 'GL_MAX_VERTEX_SHADER_LOCALS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT',
'GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT',
'GL_VERTEX_SHADER_INSTRUCTIONS_EXT', 'GL_VERTEX_SHADER_VARIANTS_EXT',
'GL_VERTEX_SHADER_INVARIANTS_EXT', 'GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',
'GL_VERTEX_SHADER_LOCALS_EXT', 'GL_VERTEX_SHADER_OPTIMIZED_EXT', 'GL_X_EXT',
'GL_Y_EXT', 'GL_Z_EXT', 'GL_W_EXT', 'GL_NEGATIVE_X_EXT', 'GL_NEGATIVE_Y_EXT',
'GL_NEGATIVE_Z_EXT', 'GL_NEGATIVE_W_EXT', 'GL_ZERO_EXT', 'GL_ONE_EXT',
'GL_NEGATIVE_ONE_EXT', 'GL_NORMALIZED_RANGE_EXT', 'GL_FULL_RANGE_EXT',
'GL_CURRENT_VERTEX_EXT', 'GL_MVP_MATRIX_EXT', 'GL_VARIANT_VALUE_EXT',
'GL_VARIANT_DATATYPE_EXT', 'GL_VARIANT_ARRAY_STRIDE_EXT',
'GL_VARIANT_ARRAY_TYPE_EXT', 'GL_VARIANT_ARRAY_EXT',
'GL_VARIANT_ARRAY_POINTER_EXT', 'GL_INVARIANT_VALUE_EXT',
'GL_INVARIANT_DATATYPE_EXT', 'GL_LOCAL_CONSTANT_VALUE_EXT',
'GL_LOCAL_CONSTANT_DATATYPE_EXT', 'GL_MAX_VERTEX_STREAMS_ATI',
'GL_VERTEX_STREAM0_ATI', 'GL_VERTEX_STREAM1_ATI', 'GL_VERTEX_STREAM2_ATI',
'GL_VERTEX_STREAM3_ATI', 'GL_VERTEX_STREAM4_ATI', 'GL_VERTEX_STREAM5_ATI',
'GL_VERTEX_STREAM6_ATI', 'GL_VERTEX_STREAM7_ATI', 'GL_VERTEX_SOURCE_ATI',
'GL_ELEMENT_ARRAY_ATI', 'GL_ELEMENT_ARRAY_TYPE_ATI',
'GL_ELEMENT_ARRAY_POINTER_ATI', 'GL_QUAD_MESH_SUN', 'GL_TRIANGLE_MESH_SUN',
'GL_SLICE_ACCUM_SUN', 'GL_MULTISAMPLE_FILTER_HINT_NV', 'GL_DEPTH_CLAMP_NV',
'GL_PIXEL_COUNTER_BITS_NV', 'GL_CURRENT_OCCLUSION_QUERY_ID_NV',
'GL_PIXEL_COUNT_NV', 'GL_PIXEL_COUNT_AVAILABLE_NV', 'GL_POINT_SPRITE_NV',
'GL_COORD_REPLACE_NV', 'GL_POINT_SPRITE_R_MODE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV',
'GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV',
'GL_OFFSET_HILO_TEXTURE_2D_NV', 'GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV',
'GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV',
'GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV',
'GL_DEPENDENT_HILO_TEXTURE_2D_NV', 'GL_DEPENDENT_RGB_TEXTURE_3D_NV',
'GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV', 'GL_DOT_PRODUCT_PASS_THROUGH_NV',
'GL_DOT_PRODUCT_TEXTURE_1D_NV', 'GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV',
'GL_HILO8_NV', 'GL_SIGNED_HILO8_NV', 'GL_FORCE_BLUE_TO_ONE_NV',
'GL_STENCIL_TEST_TWO_SIDE_EXT', 'GL_ACTIVE_STENCIL_FACE_EXT',
'GL_TEXT_FRAGMENT_SHADER_ATI', 'GL_UNPACK_CLIENT_STORAGE_APPLE',
'GL_ELEMENT_ARRAY_APPLE', 'GL_ELEMENT_ARRAY_TYPE_APPLE',
'GL_ELEMENT_ARRAY_POINTER_APPLE', 'GL_DRAW_PIXELS_APPLE', 'GL_FENCE_APPLE',
'GL_VERTEX_ARRAY_BINDING_APPLE', 'GL_VERTEX_ARRAY_RANGE_APPLE',
'GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE', 'GL_VERTEX_ARRAY_STORAGE_HINT_APPLE',
'GL_VERTEX_ARRAY_RANGE_POINTER_APPLE', 'GL_STORAGE_CLIENT_APPLE',
'GL_STORAGE_CACHED_APPLE', 'GL_STORAGE_SHARED_APPLE', 'GL_YCBCR_422_APPLE',
'GL_UNSIGNED_SHORT_8_8_APPLE', 'GL_UNSIGNED_SHORT_8_8_REV_APPLE',
'GL_RGB_S3TC', 'GL_RGB4_S3TC', 'GL_RGBA_S3TC', 'GL_RGBA4_S3TC',
'GL_MAX_DRAW_BUFFERS_ATI', 'GL_DRAW_BUFFER0_ATI', 'GL_DRAW_BUFFER1_ATI',
'GL_DRAW_BUFFER2_ATI', 'GL_DRAW_BUFFER3_ATI', 'GL_DRAW_BUFFER4_ATI',
'GL_DRAW_BUFFER5_ATI', 'GL_DRAW_BUFFER6_ATI', 'GL_DRAW_BUFFER7_ATI',
'GL_DRAW_BUFFER8_ATI', 'GL_DRAW_BUFFER9_ATI', 'GL_DRAW_BUFFER10_ATI',
'GL_DRAW_BUFFER11_ATI', 'GL_DRAW_BUFFER12_ATI', 'GL_DRAW_BUFFER13_ATI',
'GL_DRAW_BUFFER14_ATI', 'GL_DRAW_BUFFER15_ATI', 'GL_TYPE_RGBA_FLOAT_ATI',
'GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI', 'GL_MODULATE_ADD_ATI',
'GL_MODULATE_SIGNED_ADD_ATI', 'GL_MODULATE_SUBTRACT_ATI',
'GL_RGBA_FLOAT32_ATI', 'GL_RGB_FLOAT32_ATI', 'GL_ALPHA_FLOAT32_ATI',
'GL_INTENSITY_FLOAT32_ATI', 'GL_LUMINANCE_FLOAT32_ATI',
'GL_LUMINANCE_ALPHA_FLOAT32_ATI', 'GL_RGBA_FLOAT16_ATI', 'GL_RGB_FLOAT16_ATI',
'GL_ALPHA_FLOAT16_ATI', 'GL_INTENSITY_FLOAT16_ATI',
'GL_LUMINANCE_FLOAT16_ATI', 'GL_LUMINANCE_ALPHA_FLOAT16_ATI', 'GL_FLOAT_R_NV',
'GL_FLOAT_RG_NV', 'GL_FLOAT_RGB_NV', 'GL_FLOAT_RGBA_NV', 'GL_FLOAT_R16_NV',
'GL_FLOAT_R32_NV', 'GL_FLOAT_RG16_NV', 'GL_FLOAT_RG32_NV',
'GL_FLOAT_RGB16_NV', 'GL_FLOAT_RGB32_NV', 'GL_FLOAT_RGBA16_NV',
'GL_FLOAT_RGBA32_NV', 'GL_TEXTURE_FLOAT_COMPONENTS_NV',
'GL_FLOAT_CLEAR_COLOR_VALUE_NV', 'GL_FLOAT_RGBA_MODE_NV',
'GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV', 'GL_FRAGMENT_PROGRAM_NV',
'GL_MAX_TEXTURE_COORDS_NV', 'GL_MAX_TEXTURE_IMAGE_UNITS_NV',
'GL_FRAGMENT_PROGRAM_BINDING_NV', 'GL_PROGRAM_ERROR_STRING_NV',
'GL_HALF_FLOAT_NV', 'GL_WRITE_PIXEL_DATA_RANGE_NV',
'GL_READ_PIXEL_DATA_RANGE_NV', 'GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV',
'GL_READ_PIXEL_DATA_RANGE_LENGTH_NV', 'GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV',
'GL_READ_PIXEL_DATA_RANGE_POINTER_NV', 'GL_PRIMITIVE_RESTART_NV',
'GL_PRIMITIVE_RESTART_INDEX_NV', 'GL_TEXTURE_UNSIGNED_REMAP_MODE_NV',
'GL_STENCIL_BACK_FUNC_ATI', 'GL_STENCIL_BACK_FAIL_ATI',
'GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI', 'GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI',
'GL_IMPLEMENTATION_COLOR_READ_TYPE_OES',
'GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES', 'GL_DEPTH_BOUNDS_TEST_EXT',
'GL_DEPTH_BOUNDS_EXT', 'GL_MIRROR_CLAMP_EXT', 'GL_MIRROR_CLAMP_TO_EDGE_EXT',
'GL_MIRROR_CLAMP_TO_BORDER_EXT', 'GL_BLEND_EQUATION_RGB_EXT',
'GL_BLEND_EQUATION_ALPHA_EXT', 'GL_PACK_INVERT_MESA',
'GL_UNSIGNED_SHORT_8_8_MESA', 'GL_UNSIGNED_SHORT_8_8_REV_MESA',
'GL_YCBCR_MESA', 'GL_PIXEL_PACK_BUFFER_EXT', 'GL_PIXEL_UNPACK_BUFFER_EXT',
'GL_PIXEL_PACK_BUFFER_BINDING_EXT', 'GL_PIXEL_UNPACK_BUFFER_BINDING_EXT',
'GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV', 'GL_MAX_PROGRAM_CALL_DEPTH_NV',
'GL_MAX_PROGRAM_IF_DEPTH_NV', 'GL_MAX_PROGRAM_LOOP_DEPTH_NV',
'GL_MAX_PROGRAM_LOOP_COUNT_NV', 'GL_INVALID_FRAMEBUFFER_OPERATION_EXT',
'GL_MAX_RENDERBUFFER_SIZE_EXT', 'GL_FRAMEBUFFER_BINDING_EXT',
'GL_RENDERBUFFER_BINDING_EXT', 'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT',
'GL_FRAMEBUFFER_COMPLETE_EXT', 'GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT', 'GL_FRAMEBUFFER_UNSUPPORTED_EXT',
'GL_MAX_COLOR_ATTACHMENTS_EXT', 'GL_COLOR_ATTACHMENT0_EXT',
'GL_COLOR_ATTACHMENT1_EXT', 'GL_COLOR_ATTACHMENT2_EXT',
'GL_COLOR_ATTACHMENT3_EXT', 'GL_COLOR_ATTACHMENT4_EXT',
'GL_COLOR_ATTACHMENT5_EXT', 'GL_COLOR_ATTACHMENT6_EXT',
'GL_COLOR_ATTACHMENT7_EXT', 'GL_COLOR_ATTACHMENT8_EXT',
'GL_COLOR_ATTACHMENT9_EXT', 'GL_COLOR_ATTACHMENT10_EXT',
'GL_COLOR_ATTACHMENT11_EXT', 'GL_COLOR_ATTACHMENT12_EXT',
'GL_COLOR_ATTACHMENT13_EXT', 'GL_COLOR_ATTACHMENT14_EXT',
'GL_COLOR_ATTACHMENT15_EXT', 'GL_DEPTH_ATTACHMENT_EXT',
'GL_STENCIL_ATTACHMENT_EXT', 'GL_FRAMEBUFFER_EXT', 'GL_RENDERBUFFER_EXT',
'GL_RENDERBUFFER_WIDTH_EXT', 'GL_RENDERBUFFER_HEIGHT_EXT',
'GL_RENDERBUFFER_INTERNAL_FORMAT_EXT', 'GL_STENCIL_INDEX1_EXT',
'GL_STENCIL_INDEX4_EXT', 'GL_STENCIL_INDEX8_EXT', 'GL_STENCIL_INDEX16_EXT',
'GL_RENDERBUFFER_RED_SIZE_EXT', 'GL_RENDERBUFFER_GREEN_SIZE_EXT',
'GL_RENDERBUFFER_BLUE_SIZE_EXT', 'GL_RENDERBUFFER_ALPHA_SIZE_EXT',
'GL_RENDERBUFFER_DEPTH_SIZE_EXT', 'GL_RENDERBUFFER_STENCIL_SIZE_EXT',
'GL_DEPTH_STENCIL_EXT', 'GL_UNSIGNED_INT_24_8_EXT', 'GL_DEPTH24_STENCIL8_EXT',
'GL_TEXTURE_STENCIL_SIZE_EXT', 'GL_STENCIL_TAG_BITS_EXT',
'GL_STENCIL_CLEAR_TAG_VALUE_EXT', 'GL_SRGB_EXT', 'GL_SRGB8_EXT',
'GL_SRGB_ALPHA_EXT', 'GL_SRGB8_ALPHA8_EXT', 'GL_SLUMINANCE_ALPHA_EXT',
'GL_SLUMINANCE8_ALPHA8_EXT', 'GL_SLUMINANCE_EXT', 'GL_SLUMINANCE8_EXT',
'GL_COMPRESSED_SRGB_EXT', 'GL_COMPRESSED_SRGB_ALPHA_EXT',
'GL_COMPRESSED_SLUMINANCE_EXT', 'GL_COMPRESSED_SLUMINANCE_ALPHA_EXT',
'GL_COMPRESSED_SRGB_S3TC_DXT1_EXT', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT',
'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT',
'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT', 'GL_READ_FRAMEBUFFER_EXT',
'GL_DRAW_FRAMEBUFFER_EXT', 'GL_DRAW_FRAMEBUFFER_BINDING_EXT',
'GL_READ_FRAMEBUFFER_BINDING_EXT', 'GL_RENDERBUFFER_SAMPLES_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT', 'GL_MAX_SAMPLES_EXT',
'GL_TEXTURE_1D_STACK_MESAX', 'GL_TEXTURE_2D_STACK_MESAX',
'GL_PROXY_TEXTURE_1D_STACK_MESAX', 'GL_PROXY_TEXTURE_2D_STACK_MESAX',
'GL_TEXTURE_1D_STACK_BINDING_MESAX', 'GL_TEXTURE_2D_STACK_BINDING_MESAX',
'GL_TIME_ELAPSED_EXT', 'GL_BUFFER_SERIALIZED_MODIFY_APPLE',
'GL_BUFFER_FLUSHING_UNMAP_APPLE', 'GL_MIN_PROGRAM_TEXEL_OFFSET_NV',
'GL_MAX_PROGRAM_TEXEL_OFFSET_NV', 'GL_PROGRAM_ATTRIB_COMPONENTS_NV',
'GL_PROGRAM_RESULT_COMPONENTS_NV', 'GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV',
'GL_MAX_PROGRAM_RESULT_COMPONENTS_NV', 'GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV',
'GL_MAX_PROGRAM_GENERIC_RESULTS_NV', 'GL_LINES_ADJACENCY_EXT',
'GL_LINE_STRIP_ADJACENCY_EXT', 'GL_TRIANGLES_ADJACENCY_EXT',
'GL_TRIANGLE_STRIP_ADJACENCY_EXT', 'GL_GEOMETRY_PROGRAM_NV',
'GL_MAX_PROGRAM_OUTPUT_VERTICES_NV',
'GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV', 'GL_GEOMETRY_VERTICES_OUT_EXT',
'GL_GEOMETRY_INPUT_TYPE_EXT', 'GL_GEOMETRY_OUTPUT_TYPE_EXT',
'GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT',
'GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT',
'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT', 'GL_PROGRAM_POINT_SIZE_EXT',
'GL_GEOMETRY_SHADER_EXT', 'GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT',
'GL_MAX_VERTEX_VARYING_COMPONENTS_EXT', 'GL_MAX_VARYING_COMPONENTS_EXT',
'GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT',
'GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT',
'GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT',
'GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV', 'GL_SAMPLER_1D_ARRAY_EXT',
'GL_SAMPLER_2D_ARRAY_EXT', 'GL_SAMPLER_BUFFER_EXT',
'GL_SAMPLER_1D_ARRAY_SHADOW_EXT', 'GL_SAMPLER_2D_ARRAY_SHADOW_EXT',
'GL_SAMPLER_CUBE_SHADOW_EXT', 'GL_UNSIGNED_INT_VEC2_EXT',
'GL_UNSIGNED_INT_VEC3_EXT', 'GL_UNSIGNED_INT_VEC4_EXT',
'GL_INT_SAMPLER_1D_EXT', 'GL_INT_SAMPLER_2D_EXT', 'GL_INT_SAMPLER_3D_EXT',
'GL_INT_SAMPLER_CUBE_EXT', 'GL_INT_SAMPLER_2D_RECT_EXT',
'GL_INT_SAMPLER_1D_ARRAY_EXT', 'GL_INT_SAMPLER_2D_ARRAY_EXT',
'GL_INT_SAMPLER_BUFFER_EXT', 'GL_UNSIGNED_INT_SAMPLER_1D_EXT',
'GL_UNSIGNED_INT_SAMPLER_2D_EXT', 'GL_UNSIGNED_INT_SAMPLER_3D_EXT',
'GL_UNSIGNED_INT_SAMPLER_CUBE_EXT', 'GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT',
'GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT',
'GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT', 'GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT',
'GL_R11F_G11F_B10F_EXT', 'GL_UNSIGNED_INT_10F_11F_11F_REV_EXT',
'GL_RGBA_SIGNED_COMPONENTS_EXT', 'GL_TEXTURE_1D_ARRAY_EXT',
'GL_PROXY_TEXTURE_1D_ARRAY_EXT', 'GL_TEXTURE_2D_ARRAY_EXT',
'GL_PROXY_TEXTURE_2D_ARRAY_EXT', 'GL_TEXTURE_BINDING_1D_ARRAY_EXT',
'GL_TEXTURE_BINDING_2D_ARRAY_EXT', 'GL_MAX_ARRAY_TEXTURE_LAYERS_EXT',
'GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT', 'GL_TEXTURE_BUFFER_EXT',
'GL_MAX_TEXTURE_BUFFER_SIZE_EXT', 'GL_TEXTURE_BINDING_BUFFER_EXT',
'GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT', 'GL_TEXTURE_BUFFER_FORMAT_EXT',
'GL_COMPRESSED_LUMINANCE_LATC1_EXT',
'GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT',
'GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT',
'GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT',
'GL_COMPRESSED_RED_RGTC1_EXT', 'GL_COMPRESSED_SIGNED_RED_RGTC1_EXT',
'GL_COMPRESSED_RED_GREEN_RGTC2_EXT',
'GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT', 'GL_RGB9_E5_EXT',
'GL_UNSIGNED_INT_5_9_9_9_REV_EXT', 'GL_TEXTURE_SHARED_SIZE_EXT',
'GL_DEPTH_COMPONENT32F_NV', 'GL_DEPTH32F_STENCIL8_NV',
'GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV', 'GL_DEPTH_BUFFER_FLOAT_MODE_NV',
'GL_RENDERBUFFER_COVERAGE_SAMPLES_NV', 'GL_RENDERBUFFER_COLOR_SAMPLES_NV',
'GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV', 'GL_MULTISAMPLE_COVERAGE_MODES_NV',
'GL_FRAMEBUFFER_SRGB_EXT', 'GL_FRAMEBUFFER_SRGB_CAPABLE_EXT',
'GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV',
'GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV',
'GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV',
'GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV',
'GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV', 'GL_BACK_PRIMARY_COLOR_NV',
'GL_BACK_SECONDARY_COLOR_NV', 'GL_TEXTURE_COORD_NV', 'GL_CLIP_DISTANCE_NV',
'GL_VERTEX_ID_NV', 'GL_PRIMITIVE_ID_NV', 'GL_GENERIC_ATTRIB_NV',
'GL_TRANSFORM_FEEDBACK_ATTRIBS_NV', 'GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV', 'GL_ACTIVE_VARYINGS_NV',
'GL_ACTIVE_VARYING_MAX_LENGTH_NV', 'GL_TRANSFORM_FEEDBACK_VARYINGS_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_START_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV', 'GL_TRANSFORM_FEEDBACK_RECORD_NV',
'GL_PRIMITIVES_GENERATED_NV', 'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV',
'GL_RASTERIZER_DISCARD_NV',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV', 'GL_INTERLEAVED_ATTRIBS_NV',
'GL_SEPARATE_ATTRIBS_NV', 'GL_TRANSFORM_FEEDBACK_BUFFER_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV', 'GL_LAYER_NV', 'GL_NEXT_BUFFER_NV',
'GL_SKIP_COMPONENTS4_NV', 'GL_SKIP_COMPONENTS3_NV', 'GL_SKIP_COMPONENTS2_NV',
'GL_SKIP_COMPONENTS1_NV', 'GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT',
'GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT',
'GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT', 'GL_MAX_BINDABLE_UNIFORM_SIZE_EXT',
'GL_UNIFORM_BUFFER_EXT', 'GL_UNIFORM_BUFFER_BINDING_EXT', 'GL_RGBA32UI_EXT',
'GL_RGB32UI_EXT', 'GL_ALPHA32UI_EXT', 'GL_INTENSITY32UI_EXT',
'GL_LUMINANCE32UI_EXT', 'GL_LUMINANCE_ALPHA32UI_EXT', 'GL_RGBA16UI_EXT',
'GL_RGB16UI_EXT', 'GL_ALPHA16UI_EXT', 'GL_INTENSITY16UI_EXT',
'GL_LUMINANCE16UI_EXT', 'GL_LUMINANCE_ALPHA16UI_EXT', 'GL_RGBA8UI_EXT',
'GL_RGB8UI_EXT', 'GL_ALPHA8UI_EXT', 'GL_INTENSITY8UI_EXT',
'GL_LUMINANCE8UI_EXT', 'GL_LUMINANCE_ALPHA8UI_EXT', 'GL_RGBA32I_EXT',
'GL_RGB32I_EXT', 'GL_ALPHA32I_EXT', 'GL_INTENSITY32I_EXT',
'GL_LUMINANCE32I_EXT', 'GL_LUMINANCE_ALPHA32I_EXT', 'GL_RGBA16I_EXT',
'GL_RGB16I_EXT', 'GL_ALPHA16I_EXT', 'GL_INTENSITY16I_EXT',
'GL_LUMINANCE16I_EXT', 'GL_LUMINANCE_ALPHA16I_EXT', 'GL_RGBA8I_EXT',
'GL_RGB8I_EXT', 'GL_ALPHA8I_EXT', 'GL_INTENSITY8I_EXT', 'GL_LUMINANCE8I_EXT',
'GL_LUMINANCE_ALPHA8I_EXT', 'GL_RED_INTEGER_EXT', 'GL_GREEN_INTEGER_EXT',
'GL_BLUE_INTEGER_EXT', 'GL_ALPHA_INTEGER_EXT', 'GL_RGB_INTEGER_EXT',
'GL_RGBA_INTEGER_EXT', 'GL_BGR_INTEGER_EXT', 'GL_BGRA_INTEGER_EXT',
'GL_LUMINANCE_INTEGER_EXT', 'GL_LUMINANCE_ALPHA_INTEGER_EXT',
'GL_RGBA_INTEGER_MODE_EXT', 'GL_QUERY_WAIT_NV', 'GL_QUERY_NO_WAIT_NV',
'GL_QUERY_BY_REGION_WAIT_NV', 'GL_QUERY_BY_REGION_NO_WAIT_NV', 'GL_FRAME_NV',
'GL_FIELDS_NV', 'GL_CURRENT_TIME_NV', 'GL_NUM_FILL_STREAMS_NV',
'GL_PRESENT_TIME_NV', 'GL_PRESENT_DURATION_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_EXT', 'GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT',
'GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT',
'GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT', 'GL_INTERLEAVED_ATTRIBS_EXT',
'GL_SEPARATE_ATTRIBS_EXT', 'GL_PRIMITIVES_GENERATED_EXT',
'GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT', 'GL_RASTERIZER_DISCARD_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT',
'GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT',
'GL_TRANSFORM_FEEDBACK_VARYINGS_EXT', 'GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT',
'GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT', 'GL_PROGRAM_MATRIX_EXT',
'GL_TRANSPOSE_PROGRAM_MATRIX_EXT', 'GL_PROGRAM_MATRIX_STACK_DEPTH_EXT',
'GL_TEXTURE_SWIZZLE_R_EXT', 'GL_TEXTURE_SWIZZLE_G_EXT',
'GL_TEXTURE_SWIZZLE_B_EXT', 'GL_TEXTURE_SWIZZLE_A_EXT',
'GL_TEXTURE_SWIZZLE_RGBA_EXT', 'GL_SAMPLE_POSITION_NV', 'GL_SAMPLE_MASK_NV',
'GL_SAMPLE_MASK_VALUE_NV', 'GL_TEXTURE_BINDING_RENDERBUFFER_NV',
'GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV', 'GL_TEXTURE_RENDERBUFFER_NV',
'GL_SAMPLER_RENDERBUFFER_NV', 'GL_INT_SAMPLER_RENDERBUFFER_NV',
'GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV', 'GL_MAX_SAMPLE_MASK_WORDS_NV',
'GL_TRANSFORM_FEEDBACK_NV', 'GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV',
'GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV', 'GL_TRANSFORM_FEEDBACK_BINDING_NV',
'GL_VBO_FREE_MEMORY_ATI', 'GL_TEXTURE_FREE_MEMORY_ATI',
'GL_RENDERBUFFER_FREE_MEMORY_ATI', 'GL_COUNTER_TYPE_AMD',
'GL_COUNTER_RANGE_AMD', 'GL_UNSIGNED_INT64_AMD', 'GL_PERCENTAGE_AMD',
'GL_PERFMON_RESULT_AVAILABLE_AMD', 'GL_PERFMON_RESULT_SIZE_AMD',
'GL_PERFMON_RESULT_AMD', 'GL_SAMPLER_BUFFER_AMD', 'GL_INT_SAMPLER_BUFFER_AMD',
'GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD', 'GL_TESSELLATION_MODE_AMD',
'GL_TESSELLATION_FACTOR_AMD', 'GL_DISCRETE_AMD', 'GL_CONTINUOUS_AMD',
'GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT',
'GL_FIRST_VERTEX_CONVENTION_EXT', 'GL_LAST_VERTEX_CONVENTION_EXT',
'GL_PROVOKING_VERTEX_EXT', 'GL_ALPHA_SNORM', 'GL_LUMINANCE_SNORM',
'GL_LUMINANCE_ALPHA_SNORM', 'GL_INTENSITY_SNORM', 'GL_ALPHA8_SNORM',
'GL_LUMINANCE8_SNORM', 'GL_LUMINANCE8_ALPHA8_SNORM', 'GL_INTENSITY8_SNORM',
'GL_ALPHA16_SNORM', 'GL_LUMINANCE16_SNORM', 'GL_LUMINANCE16_ALPHA16_SNORM',
'GL_INTENSITY16_SNORM', 'GL_TEXTURE_RANGE_LENGTH_APPLE',
'GL_TEXTURE_RANGE_POINTER_APPLE', 'GL_TEXTURE_STORAGE_HINT_APPLE',
'GL_STORAGE_PRIVATE_APPLE', 'GL_HALF_APPLE', 'GL_RGBA_FLOAT32_APPLE',
'GL_RGB_FLOAT32_APPLE', 'GL_ALPHA_FLOAT32_APPLE',
'GL_INTENSITY_FLOAT32_APPLE', 'GL_LUMINANCE_FLOAT32_APPLE',
'GL_LUMINANCE_ALPHA_FLOAT32_APPLE', 'GL_RGBA_FLOAT16_APPLE',
'GL_RGB_FLOAT16_APPLE', 'GL_ALPHA_FLOAT16_APPLE',
'GL_INTENSITY_FLOAT16_APPLE', 'GL_LUMINANCE_FLOAT16_APPLE',
'GL_LUMINANCE_ALPHA_FLOAT16_APPLE', 'GL_COLOR_FLOAT_APPLE',
'GL_VERTEX_ATTRIB_MAP1_APPLE', 'GL_VERTEX_ATTRIB_MAP2_APPLE',
'GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE', 'GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE',
'GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE', 'GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE',
'GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE', 'GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE',
'GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE', 'GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE',
'GL_AUX_DEPTH_STENCIL_APPLE', 'GL_BUFFER_OBJECT_APPLE', 'GL_RELEASED_APPLE',
'GL_VOLATILE_APPLE', 'GL_RETAINED_APPLE', 'GL_UNDEFINED_APPLE',
'GL_PURGEABLE_APPLE', 'GL_PACK_ROW_BYTES_APPLE', 'GL_UNPACK_ROW_BYTES_APPLE',
'GL_RGB_422_APPLE', 'GL_VIDEO_BUFFER_NV', 'GL_VIDEO_BUFFER_BINDING_NV',
'GL_FIELD_UPPER_NV', 'GL_FIELD_LOWER_NV', 'GL_NUM_VIDEO_CAPTURE_STREAMS_NV',
'GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV',
'GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV', 'GL_LAST_VIDEO_CAPTURE_STATUS_NV',
'GL_VIDEO_BUFFER_PITCH_NV', 'GL_VIDEO_COLOR_CONVERSION_MATRIX_NV',
'GL_VIDEO_COLOR_CONVERSION_MAX_NV', 'GL_VIDEO_COLOR_CONVERSION_MIN_NV',
'GL_VIDEO_COLOR_CONVERSION_OFFSET_NV', 'GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV',
'GL_PARTIAL_SUCCESS_NV', 'GL_SUCCESS_NV', 'GL_FAILURE_NV',
'GL_YCBYCR8_422_NV', 'GL_YCBAYCR8A_4224_NV',
'GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV',
'GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV',
'GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV',
'GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV', 'GL_Z4Y12Z4CB12Z4CR12_444_NV',
'GL_VIDEO_CAPTURE_FRAME_WIDTH_NV', 'GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV',
'GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV',
'GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV',
'GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV', 'GL_ACTIVE_PROGRAM_EXT',
'GL_BUFFER_GPU_ADDRESS_NV', 'GL_GPU_ADDRESS_NV',
'GL_MAX_SHADER_BUFFER_ADDRESS_NV', 'GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV',
'GL_ELEMENT_ARRAY_UNIFIED_NV', 'GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV',
'GL_VERTEX_ARRAY_ADDRESS_NV', 'GL_NORMAL_ARRAY_ADDRESS_NV',
'GL_COLOR_ARRAY_ADDRESS_NV', 'GL_INDEX_ARRAY_ADDRESS_NV',
'GL_TEXTURE_COORD_ARRAY_ADDRESS_NV', 'GL_EDGE_FLAG_ARRAY_ADDRESS_NV',
'GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV', 'GL_FOG_COORD_ARRAY_ADDRESS_NV',
'GL_ELEMENT_ARRAY_ADDRESS_NV', 'GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV',
'GL_VERTEX_ARRAY_LENGTH_NV', 'GL_NORMAL_ARRAY_LENGTH_NV',
'GL_COLOR_ARRAY_LENGTH_NV', 'GL_INDEX_ARRAY_LENGTH_NV',
'GL_TEXTURE_COORD_ARRAY_LENGTH_NV', 'GL_EDGE_FLAG_ARRAY_LENGTH_NV',
'GL_SECONDARY_COLOR_ARRAY_LENGTH_NV', 'GL_FOG_COORD_ARRAY_LENGTH_NV',
'GL_ELEMENT_ARRAY_LENGTH_NV', 'GL_DRAW_INDIRECT_UNIFIED_NV',
'GL_DRAW_INDIRECT_ADDRESS_NV', 'GL_DRAW_INDIRECT_LENGTH_NV',
'GL_MAX_IMAGE_UNITS_EXT',
'GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT',
'GL_IMAGE_BINDING_NAME_EXT', 'GL_IMAGE_BINDING_LEVEL_EXT',
'GL_IMAGE_BINDING_LAYERED_EXT', 'GL_IMAGE_BINDING_LAYER_EXT',
'GL_IMAGE_BINDING_ACCESS_EXT', 'GL_IMAGE_1D_EXT', 'GL_IMAGE_2D_EXT',
'GL_IMAGE_3D_EXT', 'GL_IMAGE_2D_RECT_EXT', 'GL_IMAGE_CUBE_EXT',
'GL_IMAGE_BUFFER_EXT', 'GL_IMAGE_1D_ARRAY_EXT', 'GL_IMAGE_2D_ARRAY_EXT',
'GL_IMAGE_CUBE_MAP_ARRAY_EXT', 'GL_IMAGE_2D_MULTISAMPLE_EXT',
'GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT', 'GL_INT_IMAGE_1D_EXT',
'GL_INT_IMAGE_2D_EXT', 'GL_INT_IMAGE_3D_EXT', 'GL_INT_IMAGE_2D_RECT_EXT',
'GL_INT_IMAGE_CUBE_EXT', 'GL_INT_IMAGE_BUFFER_EXT',
'GL_INT_IMAGE_1D_ARRAY_EXT', 'GL_INT_IMAGE_2D_ARRAY_EXT',
'GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT', 'GL_INT_IMAGE_2D_MULTISAMPLE_EXT',
'GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT', 'GL_UNSIGNED_INT_IMAGE_1D_EXT',
'GL_UNSIGNED_INT_IMAGE_2D_EXT', 'GL_UNSIGNED_INT_IMAGE_3D_EXT',
'GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT', 'GL_UNSIGNED_INT_IMAGE_CUBE_EXT',
'GL_UNSIGNED_INT_IMAGE_BUFFER_EXT', 'GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT',
'GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT',
'GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT',
'GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT',
'GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT', 'GL_MAX_IMAGE_SAMPLES_EXT',
'GL_IMAGE_BINDING_FORMAT_EXT', 'GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT',
'GL_ELEMENT_ARRAY_BARRIER_BIT_EXT', 'GL_UNIFORM_BARRIER_BIT_EXT',
'GL_TEXTURE_FETCH_BARRIER_BIT_EXT', 'GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT',
'GL_COMMAND_BARRIER_BIT_EXT', 'GL_PIXEL_BUFFER_BARRIER_BIT_EXT',
'GL_TEXTURE_UPDATE_BARRIER_BIT_EXT', 'GL_BUFFER_UPDATE_BARRIER_BIT_EXT',
'GL_FRAMEBUFFER_BARRIER_BIT_EXT', 'GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT',
'GL_ATOMIC_COUNTER_BARRIER_BIT_EXT', 'GL_ALL_BARRIER_BITS_EXT',
'GL_DOUBLE_VEC2_EXT', 'GL_DOUBLE_VEC3_EXT', 'GL_DOUBLE_VEC4_EXT',
'GL_DOUBLE_MAT2_EXT', 'GL_DOUBLE_MAT3_EXT', 'GL_DOUBLE_MAT4_EXT',
'GL_DOUBLE_MAT2x3_EXT', 'GL_DOUBLE_MAT2x4_EXT', 'GL_DOUBLE_MAT3x2_EXT',
'GL_DOUBLE_MAT3x4_EXT', 'GL_DOUBLE_MAT4x2_EXT', 'GL_DOUBLE_MAT4x3_EXT',
'GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV',
'GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV',
'GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV',
'GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV',
'GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV',
'GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV',
'GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV', 'GL_MAX_PROGRAM_SUBROUTINE_NUM_NV',
'GL_INT64_NV', 'GL_UNSIGNED_INT64_NV', 'GL_INT8_NV', 'GL_INT8_VEC2_NV',
'GL_INT8_VEC3_NV', 'GL_INT8_VEC4_NV', 'GL_INT16_NV', 'GL_INT16_VEC2_NV',
'GL_INT16_VEC3_NV', 'GL_INT16_VEC4_NV', 'GL_INT64_VEC2_NV',
'GL_INT64_VEC3_NV', 'GL_INT64_VEC4_NV', 'GL_UNSIGNED_INT8_NV',
'GL_UNSIGNED_INT8_VEC2_NV', 'GL_UNSIGNED_INT8_VEC3_NV',
'GL_UNSIGNED_INT8_VEC4_NV', 'GL_UNSIGNED_INT16_NV',
'GL_UNSIGNED_INT16_VEC2_NV', 'GL_UNSIGNED_INT16_VEC3_NV',
'GL_UNSIGNED_INT16_VEC4_NV', 'GL_UNSIGNED_INT64_VEC2_NV',
'GL_UNSIGNED_INT64_VEC3_NV', 'GL_UNSIGNED_INT64_VEC4_NV', 'GL_FLOAT16_NV',
'GL_FLOAT16_VEC2_NV', 'GL_FLOAT16_VEC3_NV', 'GL_FLOAT16_VEC4_NV',
'GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV', 'GL_MAX_PROGRAM_PATCH_ATTRIBS_NV',
'GL_TESS_CONTROL_PROGRAM_NV', 'GL_TESS_EVALUATION_PROGRAM_NV',
'GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV',
'GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV', 'GL_COVERAGE_SAMPLES_NV',
'GL_COLOR_SAMPLES_NV', 'GL_DATA_BUFFER_AMD', 'GL_PERFORMANCE_MONITOR_AMD',
'GL_QUERY_OBJECT_AMD', 'GL_VERTEX_ARRAY_OBJECT_AMD', 'GL_SAMPLER_OBJECT_AMD',
'GL_MAX_DEBUG_LOGGED_MESSAGES_AMD', 'GL_DEBUG_LOGGED_MESSAGES_AMD',
'GL_DEBUG_SEVERITY_HIGH_AMD', 'GL_DEBUG_SEVERITY_MEDIUM_AMD',
'GL_DEBUG_SEVERITY_LOW_AMD', 'GL_DEBUG_CATEGORY_API_ERROR_AMD',
'GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD', 'GL_DEBUG_CATEGORY_DEPRECATION_AMD',
'GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD',
'GL_DEBUG_CATEGORY_PERFORMANCE_AMD', 'GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD',
'GL_DEBUG_CATEGORY_APPLICATION_AMD', 'GL_DEBUG_CATEGORY_OTHER_AMD',
'GL_SURFACE_STATE_NV', 'GL_SURFACE_REGISTERED_NV', 'GL_SURFACE_MAPPED_NV',
'GL_WRITE_DISCARD_NV', 'GL_DEPTH_CLAMP_NEAR_AMD', 'GL_DEPTH_CLAMP_FAR_AMD',
'GL_TEXTURE_SRGB_DECODE_EXT', 'GL_DECODE_EXT', 'GL_SKIP_DECODE_EXT',
'GL_TEXTURE_COVERAGE_SAMPLES_NV', 'GL_TEXTURE_COLOR_SAMPLES_NV',
'GL_FACTOR_MIN_AMD', 'GL_FACTOR_MAX_AMD', 'GL_SUBSAMPLE_DISTANCE_AMD',
'GL_SYNC_X11_FENCE_EXT', 'GL_SCALED_RESOLVE_FASTEST_EXT',
'GL_SCALED_RESOLVE_NICEST_EXT', 'GL_PATH_FORMAT_SVG_NV',
'GL_PATH_FORMAT_PS_NV', 'GL_STANDARD_FONT_NAME_NV', 'GL_SYSTEM_FONT_NAME_NV',
'GL_FILE_NAME_NV', 'GL_PATH_STROKE_WIDTH_NV', 'GL_PATH_END_CAPS_NV',
'GL_PATH_INITIAL_END_CAP_NV', 'GL_PATH_TERMINAL_END_CAP_NV',
'GL_PATH_JOIN_STYLE_NV', 'GL_PATH_MITER_LIMIT_NV', 'GL_PATH_DASH_CAPS_NV',
'GL_PATH_INITIAL_DASH_CAP_NV', 'GL_PATH_TERMINAL_DASH_CAP_NV',
'GL_PATH_DASH_OFFSET_NV', 'GL_PATH_CLIENT_LENGTH_NV', 'GL_PATH_FILL_MODE_NV',
'GL_PATH_FILL_MASK_NV', 'GL_PATH_FILL_COVER_MODE_NV',
'GL_PATH_STROKE_COVER_MODE_NV', 'GL_PATH_STROKE_MASK_NV',
'GL_PATH_SAMPLE_QUALITY_NV', 'GL_PATH_STROKE_BOUND_NV',
'GL_PATH_STROKE_OVERSAMPLE_COUNT_NV', 'GL_COUNT_UP_NV', 'GL_COUNT_DOWN_NV',
'GL_PATH_OBJECT_BOUNDING_BOX_NV', 'GL_CONVEX_HULL_NV', 'GL_MULTI_HULLS_NV',
'GL_BOUNDING_BOX_NV', 'GL_TRANSLATE_X_NV', 'GL_TRANSLATE_Y_NV',
'GL_TRANSLATE_2D_NV', 'GL_TRANSLATE_3D_NV', 'GL_AFFINE_2D_NV',
'GL_PROJECTIVE_2D_NV', 'GL_AFFINE_3D_NV', 'GL_PROJECTIVE_3D_NV',
'GL_TRANSPOSE_AFFINE_2D_NV', 'GL_TRANSPOSE_PROJECTIVE_2D_NV',
'GL_TRANSPOSE_AFFINE_3D_NV', 'GL_TRANSPOSE_PROJECTIVE_3D_NV', 'GL_UTF8_NV',
'GL_UTF16_NV', 'GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV',
'GL_PATH_COMMAND_COUNT_NV', 'GL_PATH_COORD_COUNT_NV',
'GL_PATH_DASH_ARRAY_COUNT_NV', 'GL_PATH_COMPUTED_LENGTH_NV',
'GL_PATH_FILL_BOUNDING_BOX_NV', 'GL_PATH_STROKE_BOUNDING_BOX_NV',
'GL_SQUARE_NV', 'GL_ROUND_NV', 'GL_TRIANGULAR_NV', 'GL_BEVEL_NV',
'GL_MITER_REVERT_NV', 'GL_MITER_TRUNCATE_NV', 'GL_SKIP_MISSING_GLYPH_NV',
'GL_USE_MISSING_GLYPH_NV', 'GL_PATH_ERROR_POSITION_NV',
'GL_PATH_FOG_GEN_MODE_NV', 'GL_ACCUM_ADJACENT_PAIRS_NV',
'GL_ADJACENT_PAIRS_NV', 'GL_FIRST_TO_REST_NV', 'GL_PATH_GEN_MODE_NV',
'GL_PATH_GEN_COEFF_NV', 'GL_PATH_GEN_COLOR_FORMAT_NV',
'GL_PATH_GEN_COMPONENTS_NV', 'GL_PATH_STENCIL_FUNC_NV',
'GL_PATH_STENCIL_REF_NV', 'GL_PATH_STENCIL_VALUE_MASK_NV',
'GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV',
'GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV', 'GL_PATH_COVER_DEPTH_FUNC_NV',
'GL_PATH_DASH_OFFSET_RESET_NV', 'GL_MOVE_TO_RESETS_NV',
'GL_MOVE_TO_CONTINUES_NV', 'GL_CLOSE_PATH_NV', 'GL_MOVE_TO_NV',
'GL_RELATIVE_MOVE_TO_NV', 'GL_LINE_TO_NV', 'GL_RELATIVE_LINE_TO_NV',
'GL_HORIZONTAL_LINE_TO_NV', 'GL_RELATIVE_HORIZONTAL_LINE_TO_NV',
'GL_VERTICAL_LINE_TO_NV', 'GL_RELATIVE_VERTICAL_LINE_TO_NV',
'GL_QUADRATIC_CURVE_TO_NV', 'GL_RELATIVE_QUADRATIC_CURVE_TO_NV',
'GL_CUBIC_CURVE_TO_NV', 'GL_RELATIVE_CUBIC_CURVE_TO_NV',
'GL_SMOOTH_QUADRATIC_CURVE_TO_NV', 'GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV',
'GL_SMOOTH_CUBIC_CURVE_TO_NV', 'GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV',
'GL_SMALL_CCW_ARC_TO_NV', 'GL_RELATIVE_SMALL_CCW_ARC_TO_NV',
'GL_SMALL_CW_ARC_TO_NV', 'GL_RELATIVE_SMALL_CW_ARC_TO_NV',
'GL_LARGE_CCW_ARC_TO_NV', 'GL_RELATIVE_LARGE_CCW_ARC_TO_NV',
'GL_LARGE_CW_ARC_TO_NV', 'GL_RELATIVE_LARGE_CW_ARC_TO_NV',
'GL_RESTART_PATH_NV', 'GL_DUP_FIRST_CUBIC_CURVE_TO_NV',
'GL_DUP_LAST_CUBIC_CURVE_TO_NV', 'GL_RECT_NV', 'GL_CIRCULAR_CCW_ARC_TO_NV',
'GL_CIRCULAR_CW_ARC_TO_NV', 'GL_CIRCULAR_TANGENT_ARC_TO_NV', 'GL_ARC_TO_NV',
'GL_RELATIVE_ARC_TO_NV', 'GL_BOLD_BIT_NV', 'GL_ITALIC_BIT_NV',
'GL_GLYPH_WIDTH_BIT_NV', 'GL_GLYPH_HEIGHT_BIT_NV',
'GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV',
'GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV',
'GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV',
'GL_GLYPH_VERTICAL_BEARING_X_BIT_NV', 'GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV',
'GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV', 'GL_GLYPH_HAS_KERNING_NV',
'GL_FONT_X_MIN_BOUNDS_NV', 'GL_FONT_Y_MIN_BOUNDS_NV',
'GL_FONT_X_MAX_BOUNDS_NV', 'GL_FONT_Y_MAX_BOUNDS_NV',
'GL_FONT_UNITS_PER_EM_NV', 'GL_FONT_ASCENDER_NV', 'GL_FONT_DESCENDER_NV',
'GL_FONT_HEIGHT_NV', 'GL_FONT_MAX_ADVANCE_WIDTH_NV',
'GL_FONT_MAX_ADVANCE_HEIGHT_NV', 'GL_FONT_UNDERLINE_POSITION_NV',
'GL_FONT_UNDERLINE_THICKNESS_NV', 'GL_FONT_HAS_KERNING_NV',
'GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD', 'GL_SET_AMD', 'GL_REPLACE_VALUE_AMD',
'GL_STENCIL_OP_VALUE_AMD', 'GL_STENCIL_BACK_OP_VALUE_AMD',
'GL_QUERY_BUFFER_AMD', 'GL_QUERY_BUFFER_BINDING_AMD',
'GL_QUERY_RESULT_NO_WAIT_AMD', 'GLchar', 'GLintptr', 'GLsizeiptr',
'GLintptrARB', 'GLsizeiptrARB', 'GLcharARB', 'GLhandleARB', 'GLhalfARB',
'GLhalfNV', 'GLint64EXT', 'GLuint64EXT', 'GLint64', 'GLuint64', 'GLsync',
'GLDEBUGPROCARB', 'GLDEBUGPROCAMD', 'GLvdpauSurfaceNV',
'GL_VERSION_1_2_DEPRECATED', 'glColorTable', 'glColorTableParameterfv',
'glColorTableParameteriv', 'glCopyColorTable', 'glGetColorTable',
'glGetColorTableParameterfv', 'glGetColorTableParameteriv', 'glColorSubTable',
'glCopyColorSubTable', 'glConvolutionFilter1D', 'glConvolutionFilter2D',
'glConvolutionParameterf', 'glConvolutionParameterfv',
'glConvolutionParameteri', 'glConvolutionParameteriv',
'glCopyConvolutionFilter1D', 'glCopyConvolutionFilter2D',
'glGetConvolutionFilter', 'glGetConvolutionParameterfv',
'glGetConvolutionParameteriv', 'glGetSeparableFilter', 'glSeparableFilter2D',
'glGetHistogram', 'glGetHistogramParameterfv', 'glGetHistogramParameteriv',
'glGetMinmax', 'glGetMinmaxParameterfv', 'glGetMinmaxParameteriv',
'glHistogram', 'glMinmax', 'glResetHistogram', 'glResetMinmax',
'PFNGLCOLORTABLEPROC', 'PFNGLCOLORTABLEPARAMETERFVPROC',
'PFNGLCOLORTABLEPARAMETERIVPROC', 'PFNGLCOPYCOLORTABLEPROC',
'PFNGLGETCOLORTABLEPROC', 'PFNGLGETCOLORTABLEPARAMETERFVPROC',
'PFNGLGETCOLORTABLEPARAMETERIVPROC', 'PFNGLCOLORSUBTABLEPROC',
'PFNGLCOPYCOLORSUBTABLEPROC', 'PFNGLCONVOLUTIONFILTER1DPROC',
'PFNGLCONVOLUTIONFILTER2DPROC', 'PFNGLCONVOLUTIONPARAMETERFPROC',
'PFNGLCONVOLUTIONPARAMETERFVPROC', 'PFNGLCONVOLUTIONPARAMETERIPROC',
'PFNGLCONVOLUTIONPARAMETERIVPROC', 'PFNGLCOPYCONVOLUTIONFILTER1DPROC',
'PFNGLCOPYCONVOLUTIONFILTER2DPROC', 'PFNGLGETCONVOLUTIONFILTERPROC',
'PFNGLGETCONVOLUTIONPARAMETERFVPROC', 'PFNGLGETCONVOLUTIONPARAMETERIVPROC',
'PFNGLGETSEPARABLEFILTERPROC', 'PFNGLSEPARABLEFILTER2DPROC',
'PFNGLGETHISTOGRAMPROC', 'PFNGLGETHISTOGRAMPARAMETERFVPROC',
'PFNGLGETHISTOGRAMPARAMETERIVPROC', 'PFNGLGETMINMAXPROC',
'PFNGLGETMINMAXPARAMETERFVPROC', 'PFNGLGETMINMAXPARAMETERIVPROC',
'PFNGLHISTOGRAMPROC', 'PFNGLMINMAXPROC', 'PFNGLRESETHISTOGRAMPROC',
'PFNGLRESETMINMAXPROC', 'GL_VERSION_1_3_DEPRECATED', 'glClientActiveTexture',
'glMultiTexCoord1d', 'glMultiTexCoord1dv', 'glMultiTexCoord1f',
'glMultiTexCoord1fv', 'glMultiTexCoord1i', 'glMultiTexCoord1iv',
'glMultiTexCoord1s', 'glMultiTexCoord1sv', 'glMultiTexCoord2d',
'glMultiTexCoord2dv', 'glMultiTexCoord2f', 'glMultiTexCoord2fv',
'glMultiTexCoord2i', 'glMultiTexCoord2iv', 'glMultiTexCoord2s',
'glMultiTexCoord2sv', 'glMultiTexCoord3d', 'glMultiTexCoord3dv',
'glMultiTexCoord3f', 'glMultiTexCoord3fv', 'glMultiTexCoord3i',
'glMultiTexCoord3iv', 'glMultiTexCoord3s', 'glMultiTexCoord3sv',
'glMultiTexCoord4d', 'glMultiTexCoord4dv', 'glMultiTexCoord4f',
'glMultiTexCoord4fv', 'glMultiTexCoord4i', 'glMultiTexCoord4iv',
'glMultiTexCoord4s', 'glMultiTexCoord4sv', 'glLoadTransposeMatrixf',
'glLoadTransposeMatrixd', 'glMultTransposeMatrixf', 'glMultTransposeMatrixd',
'PFNGLCLIENTACTIVETEXTUREPROC', 'PFNGLMULTITEXCOORD1DPROC',
'PFNGLMULTITEXCOORD1DVPROC', 'PFNGLMULTITEXCOORD1FPROC',
'PFNGLMULTITEXCOORD1FVPROC', 'PFNGLMULTITEXCOORD1IPROC',
'PFNGLMULTITEXCOORD1IVPROC', 'PFNGLMULTITEXCOORD1SPROC',
'PFNGLMULTITEXCOORD1SVPROC', 'PFNGLMULTITEXCOORD2DPROC',
'PFNGLMULTITEXCOORD2DVPROC', 'PFNGLMULTITEXCOORD2FPROC',
'PFNGLMULTITEXCOORD2FVPROC', 'PFNGLMULTITEXCOORD2IPROC',
'PFNGLMULTITEXCOORD2IVPROC', 'PFNGLMULTITEXCOORD2SPROC',
'PFNGLMULTITEXCOORD2SVPROC', 'PFNGLMULTITEXCOORD3DPROC',
'PFNGLMULTITEXCOORD3DVPROC', 'PFNGLMULTITEXCOORD3FPROC',
'PFNGLMULTITEXCOORD3FVPROC', 'PFNGLMULTITEXCOORD3IPROC',
'PFNGLMULTITEXCOORD3IVPROC', 'PFNGLMULTITEXCOORD3SPROC',
'PFNGLMULTITEXCOORD3SVPROC', 'PFNGLMULTITEXCOORD4DPROC',
'PFNGLMULTITEXCOORD4DVPROC', 'PFNGLMULTITEXCOORD4FPROC',
'PFNGLMULTITEXCOORD4FVPROC', 'PFNGLMULTITEXCOORD4IPROC',
'PFNGLMULTITEXCOORD4IVPROC', 'PFNGLMULTITEXCOORD4SPROC',
'PFNGLMULTITEXCOORD4SVPROC', 'PFNGLLOADTRANSPOSEMATRIXFPROC',
'PFNGLLOADTRANSPOSEMATRIXDPROC', 'PFNGLMULTTRANSPOSEMATRIXFPROC',
'PFNGLMULTTRANSPOSEMATRIXDPROC', 'GL_VERSION_1_4', 'glBlendFuncSeparate',
'glMultiDrawArrays', 'glMultiDrawElements', 'glPointParameterf',
'glPointParameterfv', 'glPointParameteri', 'glPointParameteriv',
'PFNGLBLENDFUNCSEPARATEPROC', 'PFNGLMULTIDRAWARRAYSPROC',
'PFNGLMULTIDRAWELEMENTSPROC', 'PFNGLPOINTPARAMETERFPROC',
'PFNGLPOINTPARAMETERFVPROC', 'PFNGLPOINTPARAMETERIPROC',
'PFNGLPOINTPARAMETERIVPROC', 'GL_VERSION_1_4_DEPRECATED', 'glFogCoordf',
'glFogCoordfv', 'glFogCoordd', 'glFogCoorddv', 'glFogCoordPointer',
'glSecondaryColor3b', 'glSecondaryColor3bv', 'glSecondaryColor3d',
'glSecondaryColor3dv', 'glSecondaryColor3f', 'glSecondaryColor3fv',
'glSecondaryColor3i', 'glSecondaryColor3iv', 'glSecondaryColor3s',
'glSecondaryColor3sv', 'glSecondaryColor3ub', 'glSecondaryColor3ubv',
'glSecondaryColor3ui', 'glSecondaryColor3uiv', 'glSecondaryColor3us',
'glSecondaryColor3usv', 'glSecondaryColorPointer', 'glWindowPos2d',
'glWindowPos2dv', 'glWindowPos2f', 'glWindowPos2fv', 'glWindowPos2i',
'glWindowPos2iv', 'glWindowPos2s', 'glWindowPos2sv', 'glWindowPos3d',
'glWindowPos3dv', 'glWindowPos3f', 'glWindowPos3fv', 'glWindowPos3i',
'glWindowPos3iv', 'glWindowPos3s', 'glWindowPos3sv', 'PFNGLFOGCOORDFPROC',
'PFNGLFOGCOORDFVPROC', 'PFNGLFOGCOORDDPROC', 'PFNGLFOGCOORDDVPROC',
'PFNGLFOGCOORDPOINTERPROC', 'PFNGLSECONDARYCOLOR3BPROC',
'PFNGLSECONDARYCOLOR3BVPROC', 'PFNGLSECONDARYCOLOR3DPROC',
'PFNGLSECONDARYCOLOR3DVPROC', 'PFNGLSECONDARYCOLOR3FPROC',
'PFNGLSECONDARYCOLOR3FVPROC', 'PFNGLSECONDARYCOLOR3IPROC',
'PFNGLSECONDARYCOLOR3IVPROC', 'PFNGLSECONDARYCOLOR3SPROC',
'PFNGLSECONDARYCOLOR3SVPROC', 'PFNGLSECONDARYCOLOR3UBPROC',
'PFNGLSECONDARYCOLOR3UBVPROC', 'PFNGLSECONDARYCOLOR3UIPROC',
'PFNGLSECONDARYCOLOR3UIVPROC', 'PFNGLSECONDARYCOLOR3USPROC',
'PFNGLSECONDARYCOLOR3USVPROC', 'PFNGLSECONDARYCOLORPOINTERPROC',
'PFNGLWINDOWPOS2DPROC', 'PFNGLWINDOWPOS2DVPROC', 'PFNGLWINDOWPOS2FPROC',
'PFNGLWINDOWPOS2FVPROC', 'PFNGLWINDOWPOS2IPROC', 'PFNGLWINDOWPOS2IVPROC',
'PFNGLWINDOWPOS2SPROC', 'PFNGLWINDOWPOS2SVPROC', 'PFNGLWINDOWPOS3DPROC',
'PFNGLWINDOWPOS3DVPROC', 'PFNGLWINDOWPOS3FPROC', 'PFNGLWINDOWPOS3FVPROC',
'PFNGLWINDOWPOS3IPROC', 'PFNGLWINDOWPOS3IVPROC', 'PFNGLWINDOWPOS3SPROC',
'PFNGLWINDOWPOS3SVPROC', 'GL_VERSION_1_5', 'glGenQueries', 'glDeleteQueries',
'glIsQuery', 'glBeginQuery', 'glEndQuery', 'glGetQueryiv',
'glGetQueryObjectiv', 'glGetQueryObjectuiv', 'glBindBuffer',
'glDeleteBuffers', 'glGenBuffers', 'glIsBuffer', 'glBufferData',
'glBufferSubData', 'glGetBufferSubData', 'glMapBuffer', 'glUnmapBuffer',
'glGetBufferParameteriv', 'glGetBufferPointerv', 'PFNGLGENQUERIESPROC',
'PFNGLDELETEQUERIESPROC', 'PFNGLISQUERYPROC', 'PFNGLBEGINQUERYPROC',
'PFNGLENDQUERYPROC', 'PFNGLGETQUERYIVPROC', 'PFNGLGETQUERYOBJECTIVPROC',
'PFNGLGETQUERYOBJECTUIVPROC', 'PFNGLBINDBUFFERPROC', 'PFNGLDELETEBUFFERSPROC',
'PFNGLGENBUFFERSPROC', 'PFNGLISBUFFERPROC', 'PFNGLBUFFERDATAPROC',
'PFNGLBUFFERSUBDATAPROC', 'PFNGLGETBUFFERSUBDATAPROC', 'PFNGLMAPBUFFERPROC',
'PFNGLUNMAPBUFFERPROC', 'PFNGLGETBUFFERPARAMETERIVPROC',
'PFNGLGETBUFFERPOINTERVPROC', 'GL_VERSION_2_0', 'glBlendEquationSeparate',
'glDrawBuffers', 'glStencilOpSeparate', 'glStencilFuncSeparate',
'glStencilMaskSeparate', 'glAttachShader', 'glBindAttribLocation',
'glCompileShader', 'glCreateProgram', 'glCreateShader', 'glDeleteProgram',
'glDeleteShader', 'glDetachShader', 'glDisableVertexAttribArray',
'glEnableVertexAttribArray', 'glGetActiveAttrib', 'glGetActiveUniform',
'glGetAttachedShaders', 'glGetAttribLocation', 'glGetProgramiv',
'glGetProgramInfoLog', 'glGetShaderiv', 'glGetShaderInfoLog',
'glGetShaderSource', 'glGetUniformLocation', 'glGetUniformfv',
'glGetUniformiv', 'glGetVertexAttribdv', 'glGetVertexAttribfv',
'glGetVertexAttribiv', 'glGetVertexAttribPointerv', 'glIsProgram',
'glIsShader', 'glLinkProgram', 'glShaderSource', 'glUseProgram',
'glUniform1f', 'glUniform2f', 'glUniform3f', 'glUniform4f', 'glUniform1i',
'glUniform2i', 'glUniform3i', 'glUniform4i', 'glUniform1fv', 'glUniform2fv',
'glUniform3fv', 'glUniform4fv', 'glUniform1iv', 'glUniform2iv',
'glUniform3iv', 'glUniform4iv', 'glUniformMatrix2fv', 'glUniformMatrix3fv',
'glUniformMatrix4fv', 'glValidateProgram', 'glVertexAttrib1d',
'glVertexAttrib1dv', 'glVertexAttrib1f', 'glVertexAttrib1fv',
'glVertexAttrib1s', 'glVertexAttrib1sv', 'glVertexAttrib2d',
'glVertexAttrib2dv', 'glVertexAttrib2f', 'glVertexAttrib2fv',
'glVertexAttrib2s', 'glVertexAttrib2sv', 'glVertexAttrib3d',
'glVertexAttrib3dv', 'glVertexAttrib3f', 'glVertexAttrib3fv',
'glVertexAttrib3s', 'glVertexAttrib3sv', 'glVertexAttrib4Nbv',
'glVertexAttrib4Niv', 'glVertexAttrib4Nsv', 'glVertexAttrib4Nub',
'glVertexAttrib4Nubv', 'glVertexAttrib4Nuiv', 'glVertexAttrib4Nusv',
'glVertexAttrib4bv', 'glVertexAttrib4d', 'glVertexAttrib4dv',
'glVertexAttrib4f', 'glVertexAttrib4fv', 'glVertexAttrib4iv',
'glVertexAttrib4s', 'glVertexAttrib4sv', 'glVertexAttrib4ubv',
'glVertexAttrib4uiv', 'glVertexAttrib4usv', 'glVertexAttribPointer',
'PFNGLBLENDEQUATIONSEPARATEPROC', 'PFNGLDRAWBUFFERSPROC',
'PFNGLSTENCILOPSEPARATEPROC', 'PFNGLSTENCILFUNCSEPARATEPROC',
'PFNGLSTENCILMASKSEPARATEPROC', 'PFNGLATTACHSHADERPROC',
'PFNGLBINDATTRIBLOCATIONPROC', 'PFNGLCOMPILESHADERPROC',
'PFNGLCREATEPROGRAMPROC', 'PFNGLCREATESHADERPROC', 'PFNGLDELETEPROGRAMPROC',
'PFNGLDELETESHADERPROC', 'PFNGLDETACHSHADERPROC',
'PFNGLDISABLEVERTEXATTRIBARRAYPROC', 'PFNGLENABLEVERTEXATTRIBARRAYPROC',
'PFNGLGETACTIVEATTRIBPROC', 'PFNGLGETACTIVEUNIFORMPROC',
'PFNGLGETATTACHEDSHADERSPROC', 'PFNGLGETATTRIBLOCATIONPROC',
'PFNGLGETPROGRAMIVPROC', 'PFNGLGETPROGRAMINFOLOGPROC', 'PFNGLGETSHADERIVPROC',
'PFNGLGETSHADERINFOLOGPROC', 'PFNGLGETSHADERSOURCEPROC',
'PFNGLGETUNIFORMLOCATIONPROC', 'PFNGLGETUNIFORMFVPROC',
'PFNGLGETUNIFORMIVPROC', 'PFNGLGETVERTEXATTRIBDVPROC',
'PFNGLGETVERTEXATTRIBFVPROC', 'PFNGLGETVERTEXATTRIBIVPROC',
'PFNGLGETVERTEXATTRIBPOINTERVPROC', 'PFNGLISPROGRAMPROC', 'PFNGLISSHADERPROC',
'PFNGLLINKPROGRAMPROC', 'PFNGLSHADERSOURCEPROC', 'PFNGLUSEPROGRAMPROC',
'PFNGLUNIFORM1FPROC', 'PFNGLUNIFORM2FPROC', 'PFNGLUNIFORM3FPROC',
'PFNGLUNIFORM4FPROC', 'PFNGLUNIFORM1IPROC', 'PFNGLUNIFORM2IPROC',
'PFNGLUNIFORM3IPROC', 'PFNGLUNIFORM4IPROC', 'PFNGLUNIFORM1FVPROC',
'PFNGLUNIFORM2FVPROC', 'PFNGLUNIFORM3FVPROC', 'PFNGLUNIFORM4FVPROC',
'PFNGLUNIFORM1IVPROC', 'PFNGLUNIFORM2IVPROC', 'PFNGLUNIFORM3IVPROC',
'PFNGLUNIFORM4IVPROC', 'PFNGLUNIFORMMATRIX2FVPROC',
'PFNGLUNIFORMMATRIX3FVPROC', 'PFNGLUNIFORMMATRIX4FVPROC',
'PFNGLVALIDATEPROGRAMPROC', 'PFNGLVERTEXATTRIB1DPROC',
'PFNGLVERTEXATTRIB1DVPROC', 'PFNGLVERTEXATTRIB1FPROC',
'PFNGLVERTEXATTRIB1FVPROC', 'PFNGLVERTEXATTRIB1SPROC',
'PFNGLVERTEXATTRIB1SVPROC', 'PFNGLVERTEXATTRIB2DPROC',
'PFNGLVERTEXATTRIB2DVPROC', 'PFNGLVERTEXATTRIB2FPROC',
'PFNGLVERTEXATTRIB2FVPROC', 'PFNGLVERTEXATTRIB2SPROC',
'PFNGLVERTEXATTRIB2SVPROC', 'PFNGLVERTEXATTRIB3DPROC',
'PFNGLVERTEXATTRIB3DVPROC', 'PFNGLVERTEXATTRIB3FPROC',
'PFNGLVERTEXATTRIB3FVPROC', 'PFNGLVERTEXATTRIB3SPROC',
'PFNGLVERTEXATTRIB3SVPROC', 'PFNGLVERTEXATTRIB4NBVPROC',
'PFNGLVERTEXATTRIB4NIVPROC', 'PFNGLVERTEXATTRIB4NSVPROC',
'PFNGLVERTEXATTRIB4NUBPROC', 'PFNGLVERTEXATTRIB4NUBVPROC',
'PFNGLVERTEXATTRIB4NUIVPROC', 'PFNGLVERTEXATTRIB4NUSVPROC',
'PFNGLVERTEXATTRIB4BVPROC', 'PFNGLVERTEXATTRIB4DPROC',
'PFNGLVERTEXATTRIB4DVPROC', 'PFNGLVERTEXATTRIB4FPROC',
'PFNGLVERTEXATTRIB4FVPROC', 'PFNGLVERTEXATTRIB4IVPROC',
'PFNGLVERTEXATTRIB4SPROC', 'PFNGLVERTEXATTRIB4SVPROC',
'PFNGLVERTEXATTRIB4UBVPROC', 'PFNGLVERTEXATTRIB4UIVPROC',
'PFNGLVERTEXATTRIB4USVPROC', 'PFNGLVERTEXATTRIBPOINTERPROC', 'GL_VERSION_2_1',
'glUniformMatrix2x3fv', 'glUniformMatrix3x2fv', 'glUniformMatrix2x4fv',
'glUniformMatrix4x2fv', 'glUniformMatrix3x4fv', 'glUniformMatrix4x3fv',
'PFNGLUNIFORMMATRIX2X3FVPROC', 'PFNGLUNIFORMMATRIX3X2FVPROC',
'PFNGLUNIFORMMATRIX2X4FVPROC', 'PFNGLUNIFORMMATRIX4X2FVPROC',
'PFNGLUNIFORMMATRIX3X4FVPROC', 'PFNGLUNIFORMMATRIX4X3FVPROC',
'GL_VERSION_3_0', 'glColorMaski', 'glGetBooleani_v', 'glGetIntegeri_v',
'glEnablei', 'glDisablei', 'glIsEnabledi', 'glBeginTransformFeedback',
'glEndTransformFeedback', 'glBindBufferRange', 'glBindBufferBase',
'glTransformFeedbackVaryings', 'glGetTransformFeedbackVarying',
'glClampColor', 'glBeginConditionalRender', 'glEndConditionalRender',
'glVertexAttribIPointer', 'glGetVertexAttribIiv', 'glGetVertexAttribIuiv',
'glVertexAttribI1i', 'glVertexAttribI2i', 'glVertexAttribI3i',
'glVertexAttribI4i', 'glVertexAttribI1ui', 'glVertexAttribI2ui',
'glVertexAttribI3ui', 'glVertexAttribI4ui', 'glVertexAttribI1iv',
'glVertexAttribI2iv', 'glVertexAttribI3iv', 'glVertexAttribI4iv',
'glVertexAttribI1uiv', 'glVertexAttribI2uiv', 'glVertexAttribI3uiv',
'glVertexAttribI4uiv', 'glVertexAttribI4bv', 'glVertexAttribI4sv',
'glVertexAttribI4ubv', 'glVertexAttribI4usv', 'glGetUniformuiv',
'glBindFragDataLocation', 'glGetFragDataLocation', 'glUniform1ui',
'glUniform2ui', 'glUniform3ui', 'glUniform4ui', 'glUniform1uiv',
'glUniform2uiv', 'glUniform3uiv', 'glUniform4uiv', 'glTexParameterIiv',
'glTexParameterIuiv', 'glGetTexParameterIiv', 'glGetTexParameterIuiv',
'glClearBufferiv', 'glClearBufferuiv', 'glClearBufferfv', 'glClearBufferfi',
'glGetStringi', 'PFNGLCOLORMASKIPROC', 'PFNGLGETBOOLEANI_VPROC',
'PFNGLGETINTEGERI_VPROC', 'PFNGLENABLEIPROC', 'PFNGLDISABLEIPROC',
'PFNGLISENABLEDIPROC', 'PFNGLBEGINTRANSFORMFEEDBACKPROC',
'PFNGLENDTRANSFORMFEEDBACKPROC', 'PFNGLBINDBUFFERRANGEPROC',
'PFNGLBINDBUFFERBASEPROC', 'PFNGLTRANSFORMFEEDBACKVARYINGSPROC',
'PFNGLGETTRANSFORMFEEDBACKVARYINGPROC', 'PFNGLCLAMPCOLORPROC',
'PFNGLBEGINCONDITIONALRENDERPROC', 'PFNGLENDCONDITIONALRENDERPROC',
'PFNGLVERTEXATTRIBIPOINTERPROC', 'PFNGLGETVERTEXATTRIBIIVPROC',
'PFNGLGETVERTEXATTRIBIUIVPROC', 'PFNGLVERTEXATTRIBI1IPROC',
'PFNGLVERTEXATTRIBI2IPROC', 'PFNGLVERTEXATTRIBI3IPROC',
'PFNGLVERTEXATTRIBI4IPROC', 'PFNGLVERTEXATTRIBI1UIPROC',
'PFNGLVERTEXATTRIBI2UIPROC', 'PFNGLVERTEXATTRIBI3UIPROC',
'PFNGLVERTEXATTRIBI4UIPROC', 'PFNGLVERTEXATTRIBI1IVPROC',
'PFNGLVERTEXATTRIBI2IVPROC', 'PFNGLVERTEXATTRIBI3IVPROC',
'PFNGLVERTEXATTRIBI4IVPROC', 'PFNGLVERTEXATTRIBI1UIVPROC',
'PFNGLVERTEXATTRIBI2UIVPROC', 'PFNGLVERTEXATTRIBI3UIVPROC',
'PFNGLVERTEXATTRIBI4UIVPROC', 'PFNGLVERTEXATTRIBI4BVPROC',
'PFNGLVERTEXATTRIBI4SVPROC', 'PFNGLVERTEXATTRIBI4UBVPROC',
'PFNGLVERTEXATTRIBI4USVPROC', 'PFNGLGETUNIFORMUIVPROC',
'PFNGLBINDFRAGDATALOCATIONPROC', 'PFNGLGETFRAGDATALOCATIONPROC',
'PFNGLUNIFORM1UIPROC', 'PFNGLUNIFORM2UIPROC', 'PFNGLUNIFORM3UIPROC',
'PFNGLUNIFORM4UIPROC', 'PFNGLUNIFORM1UIVPROC', 'PFNGLUNIFORM2UIVPROC',
'PFNGLUNIFORM3UIVPROC', 'PFNGLUNIFORM4UIVPROC', 'PFNGLTEXPARAMETERIIVPROC',
'PFNGLTEXPARAMETERIUIVPROC', 'PFNGLGETTEXPARAMETERIIVPROC',
'PFNGLGETTEXPARAMETERIUIVPROC', 'PFNGLCLEARBUFFERIVPROC',
'PFNGLCLEARBUFFERUIVPROC', 'PFNGLCLEARBUFFERFVPROC', 'PFNGLCLEARBUFFERFIPROC',
'PFNGLGETSTRINGIPROC', 'GL_VERSION_3_1', 'glDrawArraysInstanced',
'glDrawElementsInstanced', 'glTexBuffer', 'glPrimitiveRestartIndex',
'PFNGLDRAWARRAYSINSTANCEDPROC', 'PFNGLDRAWELEMENTSINSTANCEDPROC',
'PFNGLTEXBUFFERPROC', 'PFNGLPRIMITIVERESTARTINDEXPROC', 'GL_VERSION_3_2',
'glGetInteger64i_v', 'glGetBufferParameteri64v', 'glFramebufferTexture',
'PFNGLGETINTEGER64I_VPROC', 'PFNGLGETBUFFERPARAMETERI64VPROC',
'PFNGLFRAMEBUFFERTEXTUREPROC', 'GL_VERSION_3_3', 'glVertexAttribDivisor',
'PFNGLVERTEXATTRIBDIVISORPROC', 'GL_VERSION_4_0', 'glMinSampleShading',
'glBlendEquationi', 'glBlendEquationSeparatei', 'glBlendFunci',
'glBlendFuncSeparatei', 'PFNGLMINSAMPLESHADINGPROC',
'PFNGLBLENDEQUATIONIPROC', 'PFNGLBLENDEQUATIONSEPARATEIPROC',
'PFNGLBLENDFUNCIPROC', 'PFNGLBLENDFUNCSEPARATEIPROC', 'GL_VERSION_4_1',
'GL_VERSION_4_2', 'GL_ARB_transpose_matrix', 'glLoadTransposeMatrixfARB',
'glLoadTransposeMatrixdARB', 'glMultTransposeMatrixfARB',
'glMultTransposeMatrixdARB', 'PFNGLLOADTRANSPOSEMATRIXFARBPROC',
'PFNGLLOADTRANSPOSEMATRIXDARBPROC', 'PFNGLMULTTRANSPOSEMATRIXFARBPROC',
'PFNGLMULTTRANSPOSEMATRIXDARBPROC', 'GL_ARB_multisample',
'glSampleCoverageARB', 'PFNGLSAMPLECOVERAGEARBPROC', 'GL_ARB_texture_env_add',
'GL_ARB_texture_cube_map', 'GL_ARB_texture_compression',
'glCompressedTexImage3DARB', 'glCompressedTexImage2DARB',
'glCompressedTexImage1DARB', 'glCompressedTexSubImage3DARB',
'glCompressedTexSubImage2DARB', 'glCompressedTexSubImage1DARB',
'glGetCompressedTexImageARB', 'PFNGLCOMPRESSEDTEXIMAGE3DARBPROC',
'PFNGLCOMPRESSEDTEXIMAGE2DARBPROC', 'PFNGLCOMPRESSEDTEXIMAGE1DARBPROC',
'PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC', 'PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC',
'PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC', 'PFNGLGETCOMPRESSEDTEXIMAGEARBPROC',
'GL_ARB_texture_border_clamp', 'GL_ARB_point_parameters',
'glPointParameterfARB', 'glPointParameterfvARB',
'PFNGLPOINTPARAMETERFARBPROC', 'PFNGLPOINTPARAMETERFVARBPROC',
'GL_ARB_vertex_blend', 'glWeightbvARB', 'glWeightsvARB', 'glWeightivARB',
'glWeightfvARB', 'glWeightdvARB', 'glWeightubvARB', 'glWeightusvARB',
'glWeightuivARB', 'glWeightPointerARB', 'glVertexBlendARB',
'PFNGLWEIGHTBVARBPROC', 'PFNGLWEIGHTSVARBPROC', 'PFNGLWEIGHTIVARBPROC',
'PFNGLWEIGHTFVARBPROC', 'PFNGLWEIGHTDVARBPROC', 'PFNGLWEIGHTUBVARBPROC',
'PFNGLWEIGHTUSVARBPROC', 'PFNGLWEIGHTUIVARBPROC', 'PFNGLWEIGHTPOINTERARBPROC',
'PFNGLVERTEXBLENDARBPROC', 'GL_ARB_matrix_palette',
'glCurrentPaletteMatrixARB', 'glMatrixIndexubvARB', 'glMatrixIndexusvARB',
'glMatrixIndexuivARB', 'glMatrixIndexPointerARB',
'PFNGLCURRENTPALETTEMATRIXARBPROC', 'PFNGLMATRIXINDEXUBVARBPROC',
'PFNGLMATRIXINDEXUSVARBPROC', 'PFNGLMATRIXINDEXUIVARBPROC',
'PFNGLMATRIXINDEXPOINTERARBPROC', 'GL_ARB_texture_env_combine',
'GL_ARB_texture_env_crossbar', 'GL_ARB_texture_env_dot3',
'GL_ARB_texture_mirrored_repeat', 'GL_ARB_depth_texture', 'GL_ARB_shadow',
'GL_ARB_shadow_ambient', 'GL_ARB_window_pos', 'glWindowPos2dARB',
'glWindowPos2dvARB', 'glWindowPos2fARB', 'glWindowPos2fvARB',
'glWindowPos2iARB', 'glWindowPos2ivARB', 'glWindowPos2sARB',
'glWindowPos2svARB', 'glWindowPos3dARB', 'glWindowPos3dvARB',
'glWindowPos3fARB', 'glWindowPos3fvARB', 'glWindowPos3iARB',
'glWindowPos3ivARB', 'glWindowPos3sARB', 'glWindowPos3svARB',
'PFNGLWINDOWPOS2DARBPROC', 'PFNGLWINDOWPOS2DVARBPROC',
'PFNGLWINDOWPOS2FARBPROC', 'PFNGLWINDOWPOS2FVARBPROC',
'PFNGLWINDOWPOS2IARBPROC', 'PFNGLWINDOWPOS2IVARBPROC',
'PFNGLWINDOWPOS2SARBPROC', 'PFNGLWINDOWPOS2SVARBPROC',
'PFNGLWINDOWPOS3DARBPROC', 'PFNGLWINDOWPOS3DVARBPROC',
'PFNGLWINDOWPOS3FARBPROC', 'PFNGLWINDOWPOS3FVARBPROC',
'PFNGLWINDOWPOS3IARBPROC', 'PFNGLWINDOWPOS3IVARBPROC',
'PFNGLWINDOWPOS3SARBPROC', 'PFNGLWINDOWPOS3SVARBPROC',
'GL_ARB_vertex_program', 'glVertexAttrib1dARB', 'glVertexAttrib1dvARB',
'glVertexAttrib1fARB', 'glVertexAttrib1fvARB', 'glVertexAttrib1sARB',
'glVertexAttrib1svARB', 'glVertexAttrib2dARB', 'glVertexAttrib2dvARB',
'glVertexAttrib2fARB', 'glVertexAttrib2fvARB', 'glVertexAttrib2sARB',
'glVertexAttrib2svARB', 'glVertexAttrib3dARB', 'glVertexAttrib3dvARB',
'glVertexAttrib3fARB', 'glVertexAttrib3fvARB', 'glVertexAttrib3sARB',
'glVertexAttrib3svARB', 'glVertexAttrib4NbvARB', 'glVertexAttrib4NivARB',
'glVertexAttrib4NsvARB', 'glVertexAttrib4NubARB', 'glVertexAttrib4NubvARB',
'glVertexAttrib4NuivARB', 'glVertexAttrib4NusvARB', 'glVertexAttrib4bvARB',
'glVertexAttrib4dARB', 'glVertexAttrib4dvARB', 'glVertexAttrib4fARB',
'glVertexAttrib4fvARB', 'glVertexAttrib4ivARB', 'glVertexAttrib4sARB',
'glVertexAttrib4svARB', 'glVertexAttrib4ubvARB', 'glVertexAttrib4uivARB',
'glVertexAttrib4usvARB', 'glVertexAttribPointerARB',
'glEnableVertexAttribArrayARB', 'glDisableVertexAttribArrayARB',
'glProgramStringARB', 'glBindProgramARB', 'glDeleteProgramsARB',
'glGenProgramsARB', 'glProgramEnvParameter4dARB',
'glProgramEnvParameter4dvARB', 'glProgramEnvParameter4fARB',
'glProgramEnvParameter4fvARB', 'glProgramLocalParameter4dARB',
'glProgramLocalParameter4dvARB', 'glProgramLocalParameter4fARB',
'glProgramLocalParameter4fvARB', 'glGetProgramEnvParameterdvARB',
'glGetProgramEnvParameterfvARB', 'glGetProgramLocalParameterdvARB',
'glGetProgramLocalParameterfvARB', 'glGetProgramivARB',
'glGetProgramStringARB', 'glGetVertexAttribdvARB', 'glGetVertexAttribfvARB',
'glGetVertexAttribivARB', 'glGetVertexAttribPointervARB', 'glIsProgramARB',
'PFNGLVERTEXATTRIB1DARBPROC', 'PFNGLVERTEXATTRIB1DVARBPROC',
'PFNGLVERTEXATTRIB1FARBPROC', 'PFNGLVERTEXATTRIB1FVARBPROC',
'PFNGLVERTEXATTRIB1SARBPROC', 'PFNGLVERTEXATTRIB1SVARBPROC',
'PFNGLVERTEXATTRIB2DARBPROC', 'PFNGLVERTEXATTRIB2DVARBPROC',
'PFNGLVERTEXATTRIB2FARBPROC', 'PFNGLVERTEXATTRIB2FVARBPROC',
'PFNGLVERTEXATTRIB2SARBPROC', 'PFNGLVERTEXATTRIB2SVARBPROC',
'PFNGLVERTEXATTRIB3DARBPROC', 'PFNGLVERTEXATTRIB3DVARBPROC',
'PFNGLVERTEXATTRIB3FARBPROC', 'PFNGLVERTEXATTRIB3FVARBPROC',
'PFNGLVERTEXATTRIB3SARBPROC', 'PFNGLVERTEXATTRIB3SVARBPROC',
'PFNGLVERTEXATTRIB4NBVARBPROC', 'PFNGLVERTEXATTRIB4NIVARBPROC',
'PFNGLVERTEXATTRIB4NSVARBPROC', 'PFNGLVERTEXATTRIB4NUBARBPROC',
'PFNGLVERTEXATTRIB4NUBVARBPROC', 'PFNGLVERTEXATTRIB4NUIVARBPROC',
'PFNGLVERTEXATTRIB4NUSVARBPROC', 'PFNGLVERTEXATTRIB4BVARBPROC',
'PFNGLVERTEXATTRIB4DARBPROC', 'PFNGLVERTEXATTRIB4DVARBPROC',
'PFNGLVERTEXATTRIB4FARBPROC', 'PFNGLVERTEXATTRIB4FVARBPROC',
'PFNGLVERTEXATTRIB4IVARBPROC', 'PFNGLVERTEXATTRIB4SARBPROC',
'PFNGLVERTEXATTRIB4SVARBPROC', 'PFNGLVERTEXATTRIB4UBVARBPROC',
'PFNGLVERTEXATTRIB4UIVARBPROC', 'PFNGLVERTEXATTRIB4USVARBPROC',
'PFNGLVERTEXATTRIBPOINTERARBPROC', 'PFNGLENABLEVERTEXATTRIBARRAYARBPROC',
'PFNGLDISABLEVERTEXATTRIBARRAYARBPROC', 'PFNGLPROGRAMSTRINGARBPROC',
'PFNGLBINDPROGRAMARBPROC', 'PFNGLDELETEPROGRAMSARBPROC',
'PFNGLGENPROGRAMSARBPROC', 'PFNGLPROGRAMENVPARAMETER4DARBPROC',
'PFNGLPROGRAMENVPARAMETER4DVARBPROC', 'PFNGLPROGRAMENVPARAMETER4FARBPROC',
'PFNGLPROGRAMENVPARAMETER4FVARBPROC', 'PFNGLPROGRAMLOCALPARAMETER4DARBPROC',
'PFNGLPROGRAMLOCALPARAMETER4DVARBPROC', 'PFNGLPROGRAMLOCALPARAMETER4FARBPROC',
'PFNGLPROGRAMLOCALPARAMETER4FVARBPROC',
'PFNGLGETPROGRAMENVPARAMETERDVARBPROC',
'PFNGLGETPROGRAMENVPARAMETERFVARBPROC',
'PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC',
'PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC', 'PFNGLGETPROGRAMIVARBPROC',
'PFNGLGETPROGRAMSTRINGARBPROC', 'PFNGLGETVERTEXATTRIBDVARBPROC',
'PFNGLGETVERTEXATTRIBFVARBPROC', 'PFNGLGETVERTEXATTRIBIVARBPROC',
'PFNGLGETVERTEXATTRIBPOINTERVARBPROC', 'PFNGLISPROGRAMARBPROC',
'GL_ARB_fragment_program', 'GL_ARB_vertex_buffer_object', 'glBindBufferARB',
'glDeleteBuffersARB', 'glGenBuffersARB', 'glIsBufferARB', 'glBufferDataARB',
'glBufferSubDataARB', 'glGetBufferSubDataARB', 'glMapBufferARB',
'glUnmapBufferARB', 'glGetBufferParameterivARB', 'glGetBufferPointervARB',
'PFNGLBINDBUFFERARBPROC', 'PFNGLDELETEBUFFERSARBPROC',
'PFNGLGENBUFFERSARBPROC', 'PFNGLISBUFFERARBPROC', 'PFNGLBUFFERDATAARBPROC',
'PFNGLBUFFERSUBDATAARBPROC', 'PFNGLGETBUFFERSUBDATAARBPROC',
'PFNGLMAPBUFFERARBPROC', 'PFNGLUNMAPBUFFERARBPROC',
'PFNGLGETBUFFERPARAMETERIVARBPROC', 'PFNGLGETBUFFERPOINTERVARBPROC',
'GL_ARB_occlusion_query', 'glGenQueriesARB', 'glDeleteQueriesARB',
'glIsQueryARB', 'glBeginQueryARB', 'glEndQueryARB', 'glGetQueryivARB',
'glGetQueryObjectivARB', 'glGetQueryObjectuivARB', 'PFNGLGENQUERIESARBPROC',
'PFNGLDELETEQUERIESARBPROC', 'PFNGLISQUERYARBPROC', 'PFNGLBEGINQUERYARBPROC',
'PFNGLENDQUERYARBPROC', 'PFNGLGETQUERYIVARBPROC',
'PFNGLGETQUERYOBJECTIVARBPROC', 'PFNGLGETQUERYOBJECTUIVARBPROC',
'GL_ARB_shader_objects', 'glDeleteObjectARB', 'glGetHandleARB',
'glDetachObjectARB', 'glCreateShaderObjectARB', 'glShaderSourceARB',
'glCompileShaderARB', 'glCreateProgramObjectARB', 'glAttachObjectARB',
'glLinkProgramARB', 'glUseProgramObjectARB', 'glValidateProgramARB',
'glUniform1fARB', 'glUniform2fARB', 'glUniform3fARB', 'glUniform4fARB',
'glUniform1iARB', 'glUniform2iARB', 'glUniform3iARB', 'glUniform4iARB',
'glUniform1fvARB', 'glUniform2fvARB', 'glUniform3fvARB', 'glUniform4fvARB',
'glUniform1ivARB', 'glUniform2ivARB', 'glUniform3ivARB', 'glUniform4ivARB',
'glUniformMatrix2fvARB', 'glUniformMatrix3fvARB', 'glUniformMatrix4fvARB',
'glGetObjectParameterfvARB', 'glGetObjectParameterivARB', 'glGetInfoLogARB',
'glGetAttachedObjectsARB', 'glGetUniformLocationARB', 'glGetActiveUniformARB',
'glGetUniformfvARB', 'glGetUniformivARB', 'glGetShaderSourceARB',
'PFNGLDELETEOBJECTARBPROC', 'PFNGLGETHANDLEARBPROC',
'PFNGLDETACHOBJECTARBPROC', 'PFNGLCREATESHADEROBJECTARBPROC',
'PFNGLSHADERSOURCEARBPROC', 'PFNGLCOMPILESHADERARBPROC',
'PFNGLCREATEPROGRAMOBJECTARBPROC', 'PFNGLATTACHOBJECTARBPROC',
'PFNGLLINKPROGRAMARBPROC', 'PFNGLUSEPROGRAMOBJECTARBPROC',
'PFNGLVALIDATEPROGRAMARBPROC', 'PFNGLUNIFORM1FARBPROC',
'PFNGLUNIFORM2FARBPROC', 'PFNGLUNIFORM3FARBPROC', 'PFNGLUNIFORM4FARBPROC',
'PFNGLUNIFORM1IARBPROC', 'PFNGLUNIFORM2IARBPROC', 'PFNGLUNIFORM3IARBPROC',
'PFNGLUNIFORM4IARBPROC', 'PFNGLUNIFORM1FVARBPROC', 'PFNGLUNIFORM2FVARBPROC',
'PFNGLUNIFORM3FVARBPROC', 'PFNGLUNIFORM4FVARBPROC', 'PFNGLUNIFORM1IVARBPROC',
'PFNGLUNIFORM2IVARBPROC', 'PFNGLUNIFORM3IVARBPROC', 'PFNGLUNIFORM4IVARBPROC',
'PFNGLUNIFORMMATRIX2FVARBPROC', 'PFNGLUNIFORMMATRIX3FVARBPROC',
'PFNGLUNIFORMMATRIX4FVARBPROC', 'PFNGLGETOBJECTPARAMETERFVARBPROC',
'PFNGLGETOBJECTPARAMETERIVARBPROC', 'PFNGLGETINFOLOGARBPROC',
'PFNGLGETATTACHEDOBJECTSARBPROC', 'PFNGLGETUNIFORMLOCATIONARBPROC',
'PFNGLGETACTIVEUNIFORMARBPROC', 'PFNGLGETUNIFORMFVARBPROC',
'PFNGLGETUNIFORMIVARBPROC', 'PFNGLGETSHADERSOURCEARBPROC',
'GL_ARB_vertex_shader', 'glBindAttribLocationARB', 'glGetActiveAttribARB',
'glGetAttribLocationARB', 'PFNGLBINDATTRIBLOCATIONARBPROC',
'PFNGLGETACTIVEATTRIBARBPROC', 'PFNGLGETATTRIBLOCATIONARBPROC',
'GL_ARB_fragment_shader', 'GL_ARB_shading_language_100',
'GL_ARB_texture_non_power_of_two', 'GL_ARB_point_sprite',
'GL_ARB_fragment_program_shadow', 'GL_ARB_draw_buffers', 'glDrawBuffersARB',
'PFNGLDRAWBUFFERSARBPROC', 'GL_ARB_texture_rectangle',
'GL_ARB_color_buffer_float', 'glClampColorARB', 'PFNGLCLAMPCOLORARBPROC',
'GL_ARB_half_float_pixel', 'GL_ARB_texture_float',
'GL_ARB_pixel_buffer_object', 'GL_ARB_depth_buffer_float',
'GL_ARB_draw_instanced', 'glDrawArraysInstancedARB',
'glDrawElementsInstancedARB', 'PFNGLDRAWARRAYSINSTANCEDARBPROC',
'PFNGLDRAWELEMENTSINSTANCEDARBPROC', 'GL_ARB_framebuffer_object',
'glIsRenderbuffer', 'glBindRenderbuffer', 'glDeleteRenderbuffers',
'glGenRenderbuffers', 'glRenderbufferStorage', 'glGetRenderbufferParameteriv',
'glIsFramebuffer', 'glBindFramebuffer', 'glDeleteFramebuffers',
'glGenFramebuffers', 'glCheckFramebufferStatus', 'glFramebufferTexture1D',
'glFramebufferTexture2D', 'glFramebufferTexture3D',
'glFramebufferRenderbuffer', 'glGetFramebufferAttachmentParameteriv',
'glGenerateMipmap', 'glBlitFramebuffer', 'glRenderbufferStorageMultisample',
'glFramebufferTextureLayer', 'PFNGLISRENDERBUFFERPROC',
'PFNGLBINDRENDERBUFFERPROC', 'PFNGLDELETERENDERBUFFERSPROC',
'PFNGLGENRENDERBUFFERSPROC', 'PFNGLRENDERBUFFERSTORAGEPROC',
'PFNGLGETRENDERBUFFERPARAMETERIVPROC', 'PFNGLISFRAMEBUFFERPROC',
'PFNGLBINDFRAMEBUFFERPROC', 'PFNGLDELETEFRAMEBUFFERSPROC',
'PFNGLGENFRAMEBUFFERSPROC', 'PFNGLCHECKFRAMEBUFFERSTATUSPROC',
'PFNGLFRAMEBUFFERTEXTURE1DPROC', 'PFNGLFRAMEBUFFERTEXTURE2DPROC',
'PFNGLFRAMEBUFFERTEXTURE3DPROC', 'PFNGLFRAMEBUFFERRENDERBUFFERPROC',
'PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC', 'PFNGLGENERATEMIPMAPPROC',
'PFNGLBLITFRAMEBUFFERPROC', 'PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC',
'PFNGLFRAMEBUFFERTEXTURELAYERPROC', 'GL_ARB_framebuffer_sRGB',
'GL_ARB_geometry_shader4', 'glProgramParameteriARB',
'glFramebufferTextureARB', 'glFramebufferTextureLayerARB',
'glFramebufferTextureFaceARB', 'PFNGLPROGRAMPARAMETERIARBPROC',
'PFNGLFRAMEBUFFERTEXTUREARBPROC', 'PFNGLFRAMEBUFFERTEXTURELAYERARBPROC',
'PFNGLFRAMEBUFFERTEXTUREFACEARBPROC', 'GL_ARB_half_float_vertex',
'GL_ARB_instanced_arrays', 'glVertexAttribDivisorARB',
'PFNGLVERTEXATTRIBDIVISORARBPROC', 'GL_ARB_map_buffer_range',
'glMapBufferRange', 'glFlushMappedBufferRange', 'PFNGLMAPBUFFERRANGEPROC',
'PFNGLFLUSHMAPPEDBUFFERRANGEPROC', 'GL_ARB_texture_buffer_object',
'glTexBufferARB', 'PFNGLTEXBUFFERARBPROC', 'GL_ARB_texture_compression_rgtc',
'GL_ARB_texture_rg', 'GL_ARB_vertex_array_object', 'glBindVertexArray',
'glDeleteVertexArrays', 'glGenVertexArrays', 'glIsVertexArray',
'PFNGLBINDVERTEXARRAYPROC', 'PFNGLDELETEVERTEXARRAYSPROC',
'PFNGLGENVERTEXARRAYSPROC', 'PFNGLISVERTEXARRAYPROC',
'GL_ARB_uniform_buffer_object', 'glGetUniformIndices',
'glGetActiveUniformsiv', 'glGetActiveUniformName', 'glGetUniformBlockIndex',
'glGetActiveUniformBlockiv', 'glGetActiveUniformBlockName',
'glUniformBlockBinding', 'PFNGLGETUNIFORMINDICESPROC',
'PFNGLGETACTIVEUNIFORMSIVPROC', 'PFNGLGETACTIVEUNIFORMNAMEPROC',
'PFNGLGETUNIFORMBLOCKINDEXPROC', 'PFNGLGETACTIVEUNIFORMBLOCKIVPROC',
'PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC', 'PFNGLUNIFORMBLOCKBINDINGPROC',
'GL_ARB_compatibility', 'GL_ARB_copy_buffer', 'glCopyBufferSubData',
'PFNGLCOPYBUFFERSUBDATAPROC', 'GL_ARB_shader_texture_lod',
'GL_ARB_depth_clamp', 'GL_ARB_draw_elements_base_vertex',
'glDrawElementsBaseVertex', 'glDrawRangeElementsBaseVertex',
'glDrawElementsInstancedBaseVertex', 'glMultiDrawElementsBaseVertex',
'PFNGLDRAWELEMENTSBASEVERTEXPROC', 'PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC',
'PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC',
'PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC', 'GL_ARB_fragment_coord_conventions',
'GL_ARB_provoking_vertex', 'glProvokingVertex', 'PFNGLPROVOKINGVERTEXPROC',
'GL_ARB_seamless_cube_map', 'GL_ARB_sync', 'glFenceSync', 'glIsSync',
'glDeleteSync', 'glClientWaitSync', 'glWaitSync', 'glGetInteger64v',
'glGetSynciv', 'PFNGLFENCESYNCPROC', 'PFNGLISSYNCPROC', 'PFNGLDELETESYNCPROC',
'PFNGLCLIENTWAITSYNCPROC', 'PFNGLWAITSYNCPROC', 'PFNGLGETINTEGER64VPROC',
'PFNGLGETSYNCIVPROC', 'GL_ARB_texture_multisample', 'glTexImage2DMultisample',
'glTexImage3DMultisample', 'glGetMultisamplefv', 'glSampleMaski',
'PFNGLTEXIMAGE2DMULTISAMPLEPROC', 'PFNGLTEXIMAGE3DMULTISAMPLEPROC',
'PFNGLGETMULTISAMPLEFVPROC', 'PFNGLSAMPLEMASKIPROC',
'GL_ARB_vertex_array_bgra', 'GL_ARB_draw_buffers_blend',
'glBlendEquationiARB', 'glBlendEquationSeparateiARB', 'glBlendFunciARB',
'glBlendFuncSeparateiARB', 'PFNGLBLENDEQUATIONIARBPROC',
'PFNGLBLENDEQUATIONSEPARATEIARBPROC', 'PFNGLBLENDFUNCIARBPROC',
'PFNGLBLENDFUNCSEPARATEIARBPROC', 'GL_ARB_sample_shading',
'glMinSampleShadingARB', 'PFNGLMINSAMPLESHADINGARBPROC',
'GL_ARB_texture_cube_map_array', 'GL_ARB_texture_gather',
'GL_ARB_texture_query_lod', 'GL_ARB_shading_language_include',
'glNamedStringARB', 'glDeleteNamedStringARB', 'glCompileShaderIncludeARB',
'glIsNamedStringARB', 'glGetNamedStringARB', 'glGetNamedStringivARB',
'PFNGLNAMEDSTRINGARBPROC', 'PFNGLDELETENAMEDSTRINGARBPROC',
'PFNGLCOMPILESHADERINCLUDEARBPROC', 'PFNGLISNAMEDSTRINGARBPROC',
'PFNGLGETNAMEDSTRINGARBPROC', 'PFNGLGETNAMEDSTRINGIVARBPROC',
'GL_ARB_texture_compression_bptc', 'GL_ARB_blend_func_extended',
'glBindFragDataLocationIndexed', 'glGetFragDataIndex',
'PFNGLBINDFRAGDATALOCATIONINDEXEDPROC', 'PFNGLGETFRAGDATAINDEXPROC',
'GL_ARB_explicit_attrib_location', 'GL_ARB_occlusion_query2',
'GL_ARB_sampler_objects', 'glGenSamplers', 'glDeleteSamplers', 'glIsSampler',
'glBindSampler', 'glSamplerParameteri', 'glSamplerParameteriv',
'glSamplerParameterf', 'glSamplerParameterfv', 'glSamplerParameterIiv',
'glSamplerParameterIuiv', 'glGetSamplerParameteriv',
'glGetSamplerParameterIiv', 'glGetSamplerParameterfv',
'glGetSamplerParameterIuiv', 'PFNGLGENSAMPLERSPROC',
'PFNGLDELETESAMPLERSPROC', 'PFNGLISSAMPLERPROC', 'PFNGLBINDSAMPLERPROC',
'PFNGLSAMPLERPARAMETERIPROC', 'PFNGLSAMPLERPARAMETERIVPROC',
'PFNGLSAMPLERPARAMETERFPROC', 'PFNGLSAMPLERPARAMETERFVPROC',
'PFNGLSAMPLERPARAMETERIIVPROC', 'PFNGLSAMPLERPARAMETERIUIVPROC',
'PFNGLGETSAMPLERPARAMETERIVPROC', 'PFNGLGETSAMPLERPARAMETERIIVPROC',
'PFNGLGETSAMPLERPARAMETERFVPROC', 'PFNGLGETSAMPLERPARAMETERIUIVPROC',
'GL_ARB_shader_bit_encoding', 'GL_ARB_texture_rgb10_a2ui',
'GL_ARB_texture_swizzle', 'GL_ARB_timer_query', 'glQueryCounter',
'glGetQueryObjecti64v', 'glGetQueryObjectui64v', 'PFNGLQUERYCOUNTERPROC',
'PFNGLGETQUERYOBJECTI64VPROC', 'PFNGLGETQUERYOBJECTUI64VPROC',
'GL_ARB_vertex_type_2_10_10_10_rev', 'glVertexP2ui', 'glVertexP2uiv',
'glVertexP3ui', 'glVertexP3uiv', 'glVertexP4ui', 'glVertexP4uiv',
'glTexCoordP1ui', 'glTexCoordP1uiv', 'glTexCoordP2ui', 'glTexCoordP2uiv',
'glTexCoordP3ui', 'glTexCoordP3uiv', 'glTexCoordP4ui', 'glTexCoordP4uiv',
'glMultiTexCoordP1ui', 'glMultiTexCoordP1uiv', 'glMultiTexCoordP2ui',
'glMultiTexCoordP2uiv', 'glMultiTexCoordP3ui', 'glMultiTexCoordP3uiv',
'glMultiTexCoordP4ui', 'glMultiTexCoordP4uiv', 'glNormalP3ui',
'glNormalP3uiv', 'glColorP3ui', 'glColorP3uiv', 'glColorP4ui', 'glColorP4uiv',
'glSecondaryColorP3ui', 'glSecondaryColorP3uiv', 'glVertexAttribP1ui',
'glVertexAttribP1uiv', 'glVertexAttribP2ui', 'glVertexAttribP2uiv',
'glVertexAttribP3ui', 'glVertexAttribP3uiv', 'glVertexAttribP4ui',
'glVertexAttribP4uiv', 'PFNGLVERTEXP2UIPROC', 'PFNGLVERTEXP2UIVPROC',
'PFNGLVERTEXP3UIPROC', 'PFNGLVERTEXP3UIVPROC', 'PFNGLVERTEXP4UIPROC',
'PFNGLVERTEXP4UIVPROC', 'PFNGLTEXCOORDP1UIPROC', 'PFNGLTEXCOORDP1UIVPROC',
'PFNGLTEXCOORDP2UIPROC', 'PFNGLTEXCOORDP2UIVPROC', 'PFNGLTEXCOORDP3UIPROC',
'PFNGLTEXCOORDP3UIVPROC', 'PFNGLTEXCOORDP4UIPROC', 'PFNGLTEXCOORDP4UIVPROC',
'PFNGLMULTITEXCOORDP1UIPROC', 'PFNGLMULTITEXCOORDP1UIVPROC',
'PFNGLMULTITEXCOORDP2UIPROC', 'PFNGLMULTITEXCOORDP2UIVPROC',
'PFNGLMULTITEXCOORDP3UIPROC', 'PFNGLMULTITEXCOORDP3UIVPROC',
'PFNGLMULTITEXCOORDP4UIPROC', 'PFNGLMULTITEXCOORDP4UIVPROC',
'PFNGLNORMALP3UIPROC', 'PFNGLNORMALP3UIVPROC', 'PFNGLCOLORP3UIPROC',
'PFNGLCOLORP3UIVPROC', 'PFNGLCOLORP4UIPROC', 'PFNGLCOLORP4UIVPROC',
'PFNGLSECONDARYCOLORP3UIPROC', 'PFNGLSECONDARYCOLORP3UIVPROC',
'PFNGLVERTEXATTRIBP1UIPROC', 'PFNGLVERTEXATTRIBP1UIVPROC',
'PFNGLVERTEXATTRIBP2UIPROC', 'PFNGLVERTEXATTRIBP2UIVPROC',
'PFNGLVERTEXATTRIBP3UIPROC', 'PFNGLVERTEXATTRIBP3UIVPROC',
'PFNGLVERTEXATTRIBP4UIPROC', 'PFNGLVERTEXATTRIBP4UIVPROC',
'GL_ARB_draw_indirect', 'glDrawArraysIndirect', 'glDrawElementsIndirect',
'PFNGLDRAWARRAYSINDIRECTPROC', 'PFNGLDRAWELEMENTSINDIRECTPROC',
'GL_ARB_gpu_shader5', 'GL_ARB_gpu_shader_fp64', 'glUniform1d', 'glUniform2d',
'glUniform3d', 'glUniform4d', 'glUniform1dv', 'glUniform2dv', 'glUniform3dv',
'glUniform4dv', 'glUniformMatrix2dv', 'glUniformMatrix3dv',
'glUniformMatrix4dv', 'glUniformMatrix2x3dv', 'glUniformMatrix2x4dv',
'glUniformMatrix3x2dv', 'glUniformMatrix3x4dv', 'glUniformMatrix4x2dv',
'glUniformMatrix4x3dv', 'glGetUniformdv', 'PFNGLUNIFORM1DPROC',
'PFNGLUNIFORM2DPROC', 'PFNGLUNIFORM3DPROC', 'PFNGLUNIFORM4DPROC',
'PFNGLUNIFORM1DVPROC', 'PFNGLUNIFORM2DVPROC', 'PFNGLUNIFORM3DVPROC',
'PFNGLUNIFORM4DVPROC', 'PFNGLUNIFORMMATRIX2DVPROC',
'PFNGLUNIFORMMATRIX3DVPROC', 'PFNGLUNIFORMMATRIX4DVPROC',
'PFNGLUNIFORMMATRIX2X3DVPROC', 'PFNGLUNIFORMMATRIX2X4DVPROC',
'PFNGLUNIFORMMATRIX3X2DVPROC', 'PFNGLUNIFORMMATRIX3X4DVPROC',
'PFNGLUNIFORMMATRIX4X2DVPROC', 'PFNGLUNIFORMMATRIX4X3DVPROC',
'PFNGLGETUNIFORMDVPROC', 'GL_ARB_shader_subroutine',
'glGetSubroutineUniformLocation', 'glGetSubroutineIndex',
'glGetActiveSubroutineUniformiv', 'glGetActiveSubroutineUniformName',
'glGetActiveSubroutineName', 'glUniformSubroutinesuiv',
'glGetUniformSubroutineuiv', 'glGetProgramStageiv',
'PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC', 'PFNGLGETSUBROUTINEINDEXPROC',
'PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC',
'PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC', 'PFNGLGETACTIVESUBROUTINENAMEPROC',
'PFNGLUNIFORMSUBROUTINESUIVPROC', 'PFNGLGETUNIFORMSUBROUTINEUIVPROC',
'PFNGLGETPROGRAMSTAGEIVPROC', 'GL_ARB_tessellation_shader',
'glPatchParameteri', 'glPatchParameterfv', 'PFNGLPATCHPARAMETERIPROC',
'PFNGLPATCHPARAMETERFVPROC', 'GL_ARB_texture_buffer_object_rgb32',
'GL_ARB_transform_feedback2', 'glBindTransformFeedback',
'glDeleteTransformFeedbacks', 'glGenTransformFeedbacks',
'glIsTransformFeedback', 'glPauseTransformFeedback',
'glResumeTransformFeedback', 'glDrawTransformFeedback',
'PFNGLBINDTRANSFORMFEEDBACKPROC', 'PFNGLDELETETRANSFORMFEEDBACKSPROC',
'PFNGLGENTRANSFORMFEEDBACKSPROC', 'PFNGLISTRANSFORMFEEDBACKPROC',
'PFNGLPAUSETRANSFORMFEEDBACKPROC', 'PFNGLRESUMETRANSFORMFEEDBACKPROC',
'PFNGLDRAWTRANSFORMFEEDBACKPROC', 'GL_ARB_transform_feedback3',
'glDrawTransformFeedbackStream', 'glBeginQueryIndexed', 'glEndQueryIndexed',
'glGetQueryIndexediv', 'PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC',
'PFNGLBEGINQUERYINDEXEDPROC', 'PFNGLENDQUERYINDEXEDPROC',
'PFNGLGETQUERYINDEXEDIVPROC', 'GL_ARB_ES2_compatibility',
'glReleaseShaderCompiler', 'glShaderBinary', 'glGetShaderPrecisionFormat',
'glDepthRangef', 'glClearDepthf', 'PFNGLRELEASESHADERCOMPILERPROC',
'PFNGLSHADERBINARYPROC', 'PFNGLGETSHADERPRECISIONFORMATPROC',
'PFNGLDEPTHRANGEFPROC', 'PFNGLCLEARDEPTHFPROC', 'GL_ARB_get_program_binary',
'glGetProgramBinary', 'glProgramBinary', 'glProgramParameteri',
'PFNGLGETPROGRAMBINARYPROC', 'PFNGLPROGRAMBINARYPROC',
'PFNGLPROGRAMPARAMETERIPROC', 'GL_ARB_separate_shader_objects',
'glUseProgramStages', 'glActiveShaderProgram', 'glCreateShaderProgramv',
'glBindProgramPipeline', 'glDeleteProgramPipelines', 'glGenProgramPipelines',
'glIsProgramPipeline', 'glGetProgramPipelineiv', 'glProgramUniform1i',
'glProgramUniform1iv', 'glProgramUniform1f', 'glProgramUniform1fv',
'glProgramUniform1d', 'glProgramUniform1dv', 'glProgramUniform1ui',
'glProgramUniform1uiv', 'glProgramUniform2i', 'glProgramUniform2iv',
'glProgramUniform2f', 'glProgramUniform2fv', 'glProgramUniform2d',
'glProgramUniform2dv', 'glProgramUniform2ui', 'glProgramUniform2uiv',
'glProgramUniform3i', 'glProgramUniform3iv', 'glProgramUniform3f',
'glProgramUniform3fv', 'glProgramUniform3d', 'glProgramUniform3dv',
'glProgramUniform3ui', 'glProgramUniform3uiv', 'glProgramUniform4i',
'glProgramUniform4iv', 'glProgramUniform4f', 'glProgramUniform4fv',
'glProgramUniform4d', 'glProgramUniform4dv', 'glProgramUniform4ui',
'glProgramUniform4uiv', 'glProgramUniformMatrix2fv',
'glProgramUniformMatrix3fv', 'glProgramUniformMatrix4fv',
'glProgramUniformMatrix2dv', 'glProgramUniformMatrix3dv',
'glProgramUniformMatrix4dv', 'glProgramUniformMatrix2x3fv',
'glProgramUniformMatrix3x2fv', 'glProgramUniformMatrix2x4fv',
'glProgramUniformMatrix4x2fv', 'glProgramUniformMatrix3x4fv',
'glProgramUniformMatrix4x3fv', 'glProgramUniformMatrix2x3dv',
'glProgramUniformMatrix3x2dv', 'glProgramUniformMatrix2x4dv',
'glProgramUniformMatrix4x2dv', 'glProgramUniformMatrix3x4dv',
'glProgramUniformMatrix4x3dv', 'glValidateProgramPipeline',
'glGetProgramPipelineInfoLog', 'PFNGLUSEPROGRAMSTAGESPROC',
'PFNGLACTIVESHADERPROGRAMPROC', 'PFNGLCREATESHADERPROGRAMVPROC',
'PFNGLBINDPROGRAMPIPELINEPROC', 'PFNGLDELETEPROGRAMPIPELINESPROC',
'PFNGLGENPROGRAMPIPELINESPROC', 'PFNGLISPROGRAMPIPELINEPROC',
'PFNGLGETPROGRAMPIPELINEIVPROC', 'PFNGLPROGRAMUNIFORM1IPROC',
'PFNGLPROGRAMUNIFORM1IVPROC', 'PFNGLPROGRAMUNIFORM1FPROC',
'PFNGLPROGRAMUNIFORM1FVPROC', 'PFNGLPROGRAMUNIFORM1DPROC',
'PFNGLPROGRAMUNIFORM1DVPROC', 'PFNGLPROGRAMUNIFORM1UIPROC',
'PFNGLPROGRAMUNIFORM1UIVPROC', 'PFNGLPROGRAMUNIFORM2IPROC',
'PFNGLPROGRAMUNIFORM2IVPROC', 'PFNGLPROGRAMUNIFORM2FPROC',
'PFNGLPROGRAMUNIFORM2FVPROC', 'PFNGLPROGRAMUNIFORM2DPROC',
'PFNGLPROGRAMUNIFORM2DVPROC', 'PFNGLPROGRAMUNIFORM2UIPROC',
'PFNGLPROGRAMUNIFORM2UIVPROC', 'PFNGLPROGRAMUNIFORM3IPROC',
'PFNGLPROGRAMUNIFORM3IVPROC', 'PFNGLPROGRAMUNIFORM3FPROC',
'PFNGLPROGRAMUNIFORM3FVPROC', 'PFNGLPROGRAMUNIFORM3DPROC',
'PFNGLPROGRAMUNIFORM3DVPROC', 'PFNGLPROGRAMUNIFORM3UIPROC',
'PFNGLPROGRAMUNIFORM3UIVPROC', 'PFNGLPROGRAMUNIFORM4IPROC',
'PFNGLPROGRAMUNIFORM4IVPROC', 'PFNGLPROGRAMUNIFORM4FPROC',
'PFNGLPROGRAMUNIFORM4FVPROC', 'PFNGLPROGRAMUNIFORM4DPROC',
'PFNGLPROGRAMUNIFORM4DVPROC', 'PFNGLPROGRAMUNIFORM4UIPROC',
'PFNGLPROGRAMUNIFORM4UIVPROC', 'PFNGLPROGRAMUNIFORMMATRIX2FVPROC',
'PFNGLPROGRAMUNIFORMMATRIX3FVPROC', 'PFNGLPROGRAMUNIFORMMATRIX4FVPROC',
'PFNGLPROGRAMUNIFORMMATRIX2DVPROC', 'PFNGLPROGRAMUNIFORMMATRIX3DVPROC',
'PFNGLPROGRAMUNIFORMMATRIX4DVPROC', 'PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC', 'PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC', 'PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC', 'PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC', 'PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC', 'PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC', 'PFNGLVALIDATEPROGRAMPIPELINEPROC',
'PFNGLGETPROGRAMPIPELINEINFOLOGPROC', 'GL_ARB_vertex_attrib_64bit',
'glVertexAttribL1d', 'glVertexAttribL2d', 'glVertexAttribL3d',
'glVertexAttribL4d', 'glVertexAttribL1dv', 'glVertexAttribL2dv',
'glVertexAttribL3dv', 'glVertexAttribL4dv', 'glVertexAttribLPointer',
'glGetVertexAttribLdv', 'PFNGLVERTEXATTRIBL1DPROC',
'PFNGLVERTEXATTRIBL2DPROC', 'PFNGLVERTEXATTRIBL3DPROC',
'PFNGLVERTEXATTRIBL4DPROC', 'PFNGLVERTEXATTRIBL1DVPROC',
'PFNGLVERTEXATTRIBL2DVPROC', 'PFNGLVERTEXATTRIBL3DVPROC',
'PFNGLVERTEXATTRIBL4DVPROC', 'PFNGLVERTEXATTRIBLPOINTERPROC',
'PFNGLGETVERTEXATTRIBLDVPROC', 'GL_ARB_viewport_array', 'glViewportArrayv',
'glViewportIndexedf', 'glViewportIndexedfv', 'glScissorArrayv',
'glScissorIndexed', 'glScissorIndexedv', 'glDepthRangeArrayv',
'glDepthRangeIndexed', 'glGetFloati_v', 'glGetDoublei_v',
'PFNGLVIEWPORTARRAYVPROC', 'PFNGLVIEWPORTINDEXEDFPROC',
'PFNGLVIEWPORTINDEXEDFVPROC', 'PFNGLSCISSORARRAYVPROC',
'PFNGLSCISSORINDEXEDPROC', 'PFNGLSCISSORINDEXEDVPROC',
'PFNGLDEPTHRANGEARRAYVPROC', 'PFNGLDEPTHRANGEINDEXEDPROC',
'PFNGLGETFLOATI_VPROC', 'PFNGLGETDOUBLEI_VPROC', 'GL_ARB_cl_event',
'glCreateSyncFromCLeventARB', 'PFNGLCREATESYNCFROMCLEVENTARBPROC',
'GL_ARB_debug_output', 'glDebugMessageControlARB', 'glDebugMessageInsertARB',
'glDebugMessageCallbackARB', 'glGetDebugMessageLogARB',
'PFNGLDEBUGMESSAGECONTROLARBPROC', 'PFNGLDEBUGMESSAGEINSERTARBPROC',
'PFNGLDEBUGMESSAGECALLBACKARBPROC', 'PFNGLGETDEBUGMESSAGELOGARBPROC',
'GL_ARB_robustness', 'glGetGraphicsResetStatusARB', 'glGetnMapdvARB',
'glGetnMapfvARB', 'glGetnMapivARB', 'glGetnPixelMapfvARB',
'glGetnPixelMapuivARB', 'glGetnPixelMapusvARB', 'glGetnPolygonStippleARB',
'glGetnColorTableARB', 'glGetnConvolutionFilterARB',
'glGetnSeparableFilterARB', 'glGetnHistogramARB', 'glGetnMinmaxARB',
'glGetnTexImageARB', 'glReadnPixelsARB', 'glGetnCompressedTexImageARB',
'glGetnUniformfvARB', 'glGetnUniformivARB', 'glGetnUniformuivARB',
'glGetnUniformdvARB', 'PFNGLGETGRAPHICSRESETSTATUSARBPROC',
'PFNGLGETNMAPDVARBPROC', 'PFNGLGETNMAPFVARBPROC', 'PFNGLGETNMAPIVARBPROC',
'PFNGLGETNPIXELMAPFVARBPROC', 'PFNGLGETNPIXELMAPUIVARBPROC',
'PFNGLGETNPIXELMAPUSVARBPROC', 'PFNGLGETNPOLYGONSTIPPLEARBPROC',
'PFNGLGETNCOLORTABLEARBPROC', 'PFNGLGETNCONVOLUTIONFILTERARBPROC',
'PFNGLGETNSEPARABLEFILTERARBPROC', 'PFNGLGETNHISTOGRAMARBPROC',
'PFNGLGETNMINMAXARBPROC', 'PFNGLGETNTEXIMAGEARBPROC',
'PFNGLREADNPIXELSARBPROC', 'PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC',
'PFNGLGETNUNIFORMFVARBPROC', 'PFNGLGETNUNIFORMIVARBPROC',
'PFNGLGETNUNIFORMUIVARBPROC', 'PFNGLGETNUNIFORMDVARBPROC',
'GL_ARB_shader_stencil_export', 'GL_ARB_base_instance',
'glDrawArraysInstancedBaseInstance', 'glDrawElementsInstancedBaseInstance',
'glDrawElementsInstancedBaseVertexBaseInstance',
'PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC',
'PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC',
'PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC',
'GL_ARB_shading_language_420pack', 'GL_ARB_transform_feedback_instanced',
'glDrawTransformFeedbackInstanced', 'glDrawTransformFeedbackStreamInstanced',
'PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC',
'PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC',
'GL_ARB_compressed_texture_pixel_storage', 'GL_ARB_conservative_depth',
'GL_ARB_internalformat_query', 'glGetInternalformativ',
'PFNGLGETINTERNALFORMATIVPROC', 'GL_ARB_map_buffer_alignment',
'GL_ARB_shader_atomic_counters', 'glGetActiveAtomicCounterBufferiv',
'PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC', 'GL_ARB_shader_image_load_store',
'glBindImageTexture', 'glMemoryBarrier', 'PFNGLBINDIMAGETEXTUREPROC',
'PFNGLMEMORYBARRIERPROC', 'GL_ARB_shading_language_packing',
'GL_ARB_texture_storage', 'glTexStorage1D', 'glTexStorage2D',
'glTexStorage3D', 'glTextureStorage1DEXT', 'glTextureStorage2DEXT',
'glTextureStorage3DEXT', 'PFNGLTEXSTORAGE1DPROC', 'PFNGLTEXSTORAGE2DPROC',
'PFNGLTEXSTORAGE3DPROC', 'PFNGLTEXTURESTORAGE1DEXTPROC',
'PFNGLTEXTURESTORAGE2DEXTPROC', 'PFNGLTEXTURESTORAGE3DEXTPROC', 'GL_EXT_abgr',
'GL_EXT_blend_color', 'glBlendColorEXT', 'PFNGLBLENDCOLOREXTPROC',
'GL_EXT_polygon_offset', 'glPolygonOffsetEXT', 'PFNGLPOLYGONOFFSETEXTPROC',
'GL_EXT_texture', 'GL_EXT_texture3D', 'glTexImage3DEXT', 'glTexSubImage3DEXT',
'PFNGLTEXIMAGE3DEXTPROC', 'PFNGLTEXSUBIMAGE3DEXTPROC',
'GL_SGIS_texture_filter4', 'glGetTexFilterFuncSGIS', 'glTexFilterFuncSGIS',
'PFNGLGETTEXFILTERFUNCSGISPROC', 'PFNGLTEXFILTERFUNCSGISPROC',
'GL_EXT_subtexture', 'glTexSubImage1DEXT', 'glTexSubImage2DEXT',
'PFNGLTEXSUBIMAGE1DEXTPROC', 'PFNGLTEXSUBIMAGE2DEXTPROC',
'GL_EXT_copy_texture', 'glCopyTexImage1DEXT', 'glCopyTexImage2DEXT',
'glCopyTexSubImage1DEXT', 'glCopyTexSubImage2DEXT', 'glCopyTexSubImage3DEXT',
'PFNGLCOPYTEXIMAGE1DEXTPROC', 'PFNGLCOPYTEXIMAGE2DEXTPROC',
'PFNGLCOPYTEXSUBIMAGE1DEXTPROC', 'PFNGLCOPYTEXSUBIMAGE2DEXTPROC',
'PFNGLCOPYTEXSUBIMAGE3DEXTPROC', 'GL_EXT_histogram', 'glGetHistogramEXT',
'glGetHistogramParameterfvEXT', 'glGetHistogramParameterivEXT',
'glGetMinmaxEXT', 'glGetMinmaxParameterfvEXT', 'glGetMinmaxParameterivEXT',
'glHistogramEXT', 'glMinmaxEXT', 'glResetHistogramEXT', 'glResetMinmaxEXT',
'PFNGLGETHISTOGRAMEXTPROC', 'PFNGLGETHISTOGRAMPARAMETERFVEXTPROC',
'PFNGLGETHISTOGRAMPARAMETERIVEXTPROC', 'PFNGLGETMINMAXEXTPROC',
'PFNGLGETMINMAXPARAMETERFVEXTPROC', 'PFNGLGETMINMAXPARAMETERIVEXTPROC',
'PFNGLHISTOGRAMEXTPROC', 'PFNGLMINMAXEXTPROC', 'PFNGLRESETHISTOGRAMEXTPROC',
'PFNGLRESETMINMAXEXTPROC', 'GL_EXT_convolution', 'glConvolutionFilter1DEXT',
'glConvolutionFilter2DEXT', 'glConvolutionParameterfEXT',
'glConvolutionParameterfvEXT', 'glConvolutionParameteriEXT',
'glConvolutionParameterivEXT', 'glCopyConvolutionFilter1DEXT',
'glCopyConvolutionFilter2DEXT', 'glGetConvolutionFilterEXT',
'glGetConvolutionParameterfvEXT', 'glGetConvolutionParameterivEXT',
'glGetSeparableFilterEXT', 'glSeparableFilter2DEXT',
'PFNGLCONVOLUTIONFILTER1DEXTPROC', 'PFNGLCONVOLUTIONFILTER2DEXTPROC',
'PFNGLCONVOLUTIONPARAMETERFEXTPROC', 'PFNGLCONVOLUTIONPARAMETERFVEXTPROC',
'PFNGLCONVOLUTIONPARAMETERIEXTPROC', 'PFNGLCONVOLUTIONPARAMETERIVEXTPROC',
'PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC', 'PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC',
'PFNGLGETCONVOLUTIONFILTEREXTPROC', 'PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC',
'PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC', 'PFNGLGETSEPARABLEFILTEREXTPROC',
'PFNGLSEPARABLEFILTER2DEXTPROC', 'GL_SGI_color_matrix', 'GL_SGI_color_table',
'glColorTableSGI', 'glColorTableParameterfvSGI', 'glColorTableParameterivSGI',
'glCopyColorTableSGI', 'glGetColorTableSGI', 'glGetColorTableParameterfvSGI',
'glGetColorTableParameterivSGI', 'PFNGLCOLORTABLESGIPROC',
'PFNGLCOLORTABLEPARAMETERFVSGIPROC', 'PFNGLCOLORTABLEPARAMETERIVSGIPROC',
'PFNGLCOPYCOLORTABLESGIPROC', 'PFNGLGETCOLORTABLESGIPROC',
'PFNGLGETCOLORTABLEPARAMETERFVSGIPROC',
'PFNGLGETCOLORTABLEPARAMETERIVSGIPROC', 'GL_SGIX_pixel_texture',
'glPixelTexGenSGIX', 'PFNGLPIXELTEXGENSGIXPROC', 'GL_SGIS_pixel_texture',
'glPixelTexGenParameteriSGIS', 'glPixelTexGenParameterivSGIS',
'glPixelTexGenParameterfSGIS', 'glPixelTexGenParameterfvSGIS',
'glGetPixelTexGenParameterivSGIS', 'glGetPixelTexGenParameterfvSGIS',
'PFNGLPIXELTEXGENPARAMETERISGISPROC', 'PFNGLPIXELTEXGENPARAMETERIVSGISPROC',
'PFNGLPIXELTEXGENPARAMETERFSGISPROC', 'PFNGLPIXELTEXGENPARAMETERFVSGISPROC',
'PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC',
'PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC', 'GL_SGIS_texture4D',
'glTexImage4DSGIS', 'glTexSubImage4DSGIS', 'PFNGLTEXIMAGE4DSGISPROC',
'PFNGLTEXSUBIMAGE4DSGISPROC', 'GL_SGI_texture_color_table', 'GL_EXT_cmyka',
'GL_EXT_texture_object', 'glAreTexturesResidentEXT', 'glBindTextureEXT',
'glDeleteTexturesEXT', 'glGenTexturesEXT', 'glIsTextureEXT',
'glPrioritizeTexturesEXT', 'PFNGLARETEXTURESRESIDENTEXTPROC',
'PFNGLBINDTEXTUREEXTPROC', 'PFNGLDELETETEXTURESEXTPROC',
'PFNGLGENTEXTURESEXTPROC', 'PFNGLISTEXTUREEXTPROC',
'PFNGLPRIORITIZETEXTURESEXTPROC', 'GL_SGIS_detail_texture',
'glDetailTexFuncSGIS', 'glGetDetailTexFuncSGIS', 'PFNGLDETAILTEXFUNCSGISPROC',
'PFNGLGETDETAILTEXFUNCSGISPROC', 'GL_SGIS_sharpen_texture',
'glSharpenTexFuncSGIS', 'glGetSharpenTexFuncSGIS',
'PFNGLSHARPENTEXFUNCSGISPROC', 'PFNGLGETSHARPENTEXFUNCSGISPROC',
'GL_EXT_packed_pixels', 'GL_SGIS_texture_lod', 'GL_SGIS_multisample',
'glSampleMaskSGIS', 'glSamplePatternSGIS', 'PFNGLSAMPLEMASKSGISPROC',
'PFNGLSAMPLEPATTERNSGISPROC', 'GL_EXT_rescale_normal', 'GL_EXT_vertex_array',
'glArrayElementEXT', 'glColorPointerEXT', 'glDrawArraysEXT',
'glEdgeFlagPointerEXT', 'glGetPointervEXT', 'glIndexPointerEXT',
'glNormalPointerEXT', 'glTexCoordPointerEXT', 'glVertexPointerEXT',
'PFNGLARRAYELEMENTEXTPROC', 'PFNGLCOLORPOINTEREXTPROC',
'PFNGLDRAWARRAYSEXTPROC', 'PFNGLEDGEFLAGPOINTEREXTPROC',
'PFNGLGETPOINTERVEXTPROC', 'PFNGLINDEXPOINTEREXTPROC',
'PFNGLNORMALPOINTEREXTPROC', 'PFNGLTEXCOORDPOINTEREXTPROC',
'PFNGLVERTEXPOINTEREXTPROC', 'GL_EXT_misc_attribute',
'GL_SGIS_generate_mipmap', 'GL_SGIX_clipmap', 'GL_SGIX_shadow',
'GL_SGIS_texture_edge_clamp', 'GL_SGIS_texture_border_clamp',
'GL_EXT_blend_minmax', 'glBlendEquationEXT', 'PFNGLBLENDEQUATIONEXTPROC',
'GL_EXT_blend_subtract', 'GL_EXT_blend_logic_op', 'GL_SGIX_interlace',
'GL_SGIX_pixel_tiles', 'GL_SGIX_texture_select', 'GL_SGIX_sprite',
'glSpriteParameterfSGIX', 'glSpriteParameterfvSGIX', 'glSpriteParameteriSGIX',
'glSpriteParameterivSGIX', 'PFNGLSPRITEPARAMETERFSGIXPROC',
'PFNGLSPRITEPARAMETERFVSGIXPROC', 'PFNGLSPRITEPARAMETERISGIXPROC',
'PFNGLSPRITEPARAMETERIVSGIXPROC', 'GL_SGIX_texture_multi_buffer',
'GL_EXT_point_parameters', 'glPointParameterfEXT', 'glPointParameterfvEXT',
'PFNGLPOINTPARAMETERFEXTPROC', 'PFNGLPOINTPARAMETERFVEXTPROC',
'GL_SGIS_point_parameters', 'glPointParameterfSGIS', 'glPointParameterfvSGIS',
'PFNGLPOINTPARAMETERFSGISPROC', 'PFNGLPOINTPARAMETERFVSGISPROC',
'GL_SGIX_instruments', 'glGetInstrumentsSGIX', 'glInstrumentsBufferSGIX',
'glPollInstrumentsSGIX', 'glReadInstrumentsSGIX', 'glStartInstrumentsSGIX',
'glStopInstrumentsSGIX', 'PFNGLGETINSTRUMENTSSGIXPROC',
'PFNGLINSTRUMENTSBUFFERSGIXPROC', 'PFNGLPOLLINSTRUMENTSSGIXPROC',
'PFNGLREADINSTRUMENTSSGIXPROC', 'PFNGLSTARTINSTRUMENTSSGIXPROC',
'PFNGLSTOPINSTRUMENTSSGIXPROC', 'GL_SGIX_texture_scale_bias',
'GL_SGIX_framezoom', 'glFrameZoomSGIX', 'PFNGLFRAMEZOOMSGIXPROC',
'GL_SGIX_tag_sample_buffer', 'glTagSampleBufferSGIX',
'PFNGLTAGSAMPLEBUFFERSGIXPROC', 'GL_SGIX_polynomial_ffd',
'glDeformationMap3dSGIX', 'glDeformationMap3fSGIX', 'glDeformSGIX',
'glLoadIdentityDeformationMapSGIX', 'PFNGLDEFORMATIONMAP3DSGIXPROC',
'PFNGLDEFORMATIONMAP3FSGIXPROC', 'PFNGLDEFORMSGIXPROC',
'PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC', 'GL_SGIX_reference_plane',
'glReferencePlaneSGIX', 'PFNGLREFERENCEPLANESGIXPROC', 'GL_SGIX_flush_raster',
'glFlushRasterSGIX', 'PFNGLFLUSHRASTERSGIXPROC', 'GL_SGIX_depth_texture',
'GL_SGIS_fog_function', 'glFogFuncSGIS', 'glGetFogFuncSGIS',
'PFNGLFOGFUNCSGISPROC', 'PFNGLGETFOGFUNCSGISPROC', 'GL_SGIX_fog_offset',
'GL_HP_image_transform', 'glImageTransformParameteriHP',
'glImageTransformParameterfHP', 'glImageTransformParameterivHP',
'glImageTransformParameterfvHP', 'glGetImageTransformParameterivHP',
'glGetImageTransformParameterfvHP', 'PFNGLIMAGETRANSFORMPARAMETERIHPPROC',
'PFNGLIMAGETRANSFORMPARAMETERFHPPROC', 'PFNGLIMAGETRANSFORMPARAMETERIVHPPROC',
'PFNGLIMAGETRANSFORMPARAMETERFVHPPROC',
'PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC',
'PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC', 'GL_HP_convolution_border_modes',
'GL_SGIX_texture_add_env', 'GL_EXT_color_subtable', 'glColorSubTableEXT',
'glCopyColorSubTableEXT', 'PFNGLCOLORSUBTABLEEXTPROC',
'PFNGLCOPYCOLORSUBTABLEEXTPROC', 'GL_PGI_vertex_hints', 'GL_PGI_misc_hints',
'glHintPGI', 'PFNGLHINTPGIPROC', 'GL_EXT_paletted_texture', 'glColorTableEXT',
'glGetColorTableEXT', 'glGetColorTableParameterivEXT',
'glGetColorTableParameterfvEXT', 'PFNGLCOLORTABLEEXTPROC',
'PFNGLGETCOLORTABLEEXTPROC', 'PFNGLGETCOLORTABLEPARAMETERIVEXTPROC',
'PFNGLGETCOLORTABLEPARAMETERFVEXTPROC', 'GL_EXT_clip_volume_hint',
'GL_SGIX_list_priority', 'glGetListParameterfvSGIX',
'glGetListParameterivSGIX', 'glListParameterfSGIX', 'glListParameterfvSGIX',
'glListParameteriSGIX', 'glListParameterivSGIX',
'PFNGLGETLISTPARAMETERFVSGIXPROC', 'PFNGLGETLISTPARAMETERIVSGIXPROC',
'PFNGLLISTPARAMETERFSGIXPROC', 'PFNGLLISTPARAMETERFVSGIXPROC',
'PFNGLLISTPARAMETERISGIXPROC', 'PFNGLLISTPARAMETERIVSGIXPROC',
'GL_SGIX_ir_instrument1', 'GL_SGIX_calligraphic_fragment',
'GL_SGIX_texture_lod_bias', 'GL_SGIX_shadow_ambient', 'GL_EXT_index_texture',
'GL_EXT_index_material', 'glIndexMaterialEXT', 'PFNGLINDEXMATERIALEXTPROC',
'GL_EXT_index_func', 'glIndexFuncEXT', 'PFNGLINDEXFUNCEXTPROC',
'GL_EXT_index_array_formats', 'GL_EXT_compiled_vertex_array',
'glLockArraysEXT', 'glUnlockArraysEXT', 'PFNGLLOCKARRAYSEXTPROC',
'PFNGLUNLOCKARRAYSEXTPROC', 'GL_EXT_cull_vertex', 'glCullParameterdvEXT',
'glCullParameterfvEXT', 'PFNGLCULLPARAMETERDVEXTPROC',
'PFNGLCULLPARAMETERFVEXTPROC', 'GL_SGIX_ycrcb', 'GL_SGIX_fragment_lighting',
'glFragmentColorMaterialSGIX', 'glFragmentLightfSGIX',
'glFragmentLightfvSGIX', 'glFragmentLightiSGIX', 'glFragmentLightivSGIX',
'glFragmentLightModelfSGIX', 'glFragmentLightModelfvSGIX',
'glFragmentLightModeliSGIX', 'glFragmentLightModelivSGIX',
'glFragmentMaterialfSGIX', 'glFragmentMaterialfvSGIX',
'glFragmentMaterialiSGIX', 'glFragmentMaterialivSGIX',
'glGetFragmentLightfvSGIX', 'glGetFragmentLightivSGIX',
'glGetFragmentMaterialfvSGIX', 'glGetFragmentMaterialivSGIX',
'glLightEnviSGIX', 'PFNGLFRAGMENTCOLORMATERIALSGIXPROC',
'PFNGLFRAGMENTLIGHTFSGIXPROC', 'PFNGLFRAGMENTLIGHTFVSGIXPROC',
'PFNGLFRAGMENTLIGHTISGIXPROC', 'PFNGLFRAGMENTLIGHTIVSGIXPROC',
'PFNGLFRAGMENTLIGHTMODELFSGIXPROC', 'PFNGLFRAGMENTLIGHTMODELFVSGIXPROC',
'PFNGLFRAGMENTLIGHTMODELISGIXPROC', 'PFNGLFRAGMENTLIGHTMODELIVSGIXPROC',
'PFNGLFRAGMENTMATERIALFSGIXPROC', 'PFNGLFRAGMENTMATERIALFVSGIXPROC',
'PFNGLFRAGMENTMATERIALISGIXPROC', 'PFNGLFRAGMENTMATERIALIVSGIXPROC',
'PFNGLGETFRAGMENTLIGHTFVSGIXPROC', 'PFNGLGETFRAGMENTLIGHTIVSGIXPROC',
'PFNGLGETFRAGMENTMATERIALFVSGIXPROC', 'PFNGLGETFRAGMENTMATERIALIVSGIXPROC',
'PFNGLLIGHTENVISGIXPROC', 'GL_IBM_rasterpos_clip', 'GL_HP_texture_lighting',
'GL_EXT_draw_range_elements', 'glDrawRangeElementsEXT',
'PFNGLDRAWRANGEELEMENTSEXTPROC', 'GL_WIN_phong_shading',
'GL_WIN_specular_fog', 'GL_EXT_light_texture', 'glApplyTextureEXT',
'glTextureLightEXT', 'glTextureMaterialEXT', 'PFNGLAPPLYTEXTUREEXTPROC',
'PFNGLTEXTURELIGHTEXTPROC', 'PFNGLTEXTUREMATERIALEXTPROC',
'GL_SGIX_blend_alpha_minmax', 'GL_EXT_bgra', 'GL_SGIX_async',
'glAsyncMarkerSGIX', 'glFinishAsyncSGIX', 'glPollAsyncSGIX',
'glGenAsyncMarkersSGIX', 'glDeleteAsyncMarkersSGIX', 'glIsAsyncMarkerSGIX',
'PFNGLASYNCMARKERSGIXPROC', 'PFNGLFINISHASYNCSGIXPROC',
'PFNGLPOLLASYNCSGIXPROC', 'PFNGLGENASYNCMARKERSSGIXPROC',
'PFNGLDELETEASYNCMARKERSSGIXPROC', 'PFNGLISASYNCMARKERSGIXPROC',
'GL_SGIX_async_pixel', 'GL_SGIX_async_histogram', 'GL_INTEL_parallel_arrays',
'glVertexPointervINTEL', 'glNormalPointervINTEL', 'glColorPointervINTEL',
'glTexCoordPointervINTEL', 'PFNGLVERTEXPOINTERVINTELPROC',
'PFNGLNORMALPOINTERVINTELPROC', 'PFNGLCOLORPOINTERVINTELPROC',
'PFNGLTEXCOORDPOINTERVINTELPROC', 'GL_HP_occlusion_test',
'GL_EXT_pixel_transform', 'glPixelTransformParameteriEXT',
'glPixelTransformParameterfEXT', 'glPixelTransformParameterivEXT',
'glPixelTransformParameterfvEXT', 'PFNGLPIXELTRANSFORMPARAMETERIEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERFEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC',
'PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC', 'GL_EXT_pixel_transform_color_table',
'GL_EXT_shared_texture_palette', 'GL_EXT_separate_specular_color',
'GL_EXT_secondary_color', 'glSecondaryColor3bEXT', 'glSecondaryColor3bvEXT',
'glSecondaryColor3dEXT', 'glSecondaryColor3dvEXT', 'glSecondaryColor3fEXT',
'glSecondaryColor3fvEXT', 'glSecondaryColor3iEXT', 'glSecondaryColor3ivEXT',
'glSecondaryColor3sEXT', 'glSecondaryColor3svEXT', 'glSecondaryColor3ubEXT',
'glSecondaryColor3ubvEXT', 'glSecondaryColor3uiEXT',
'glSecondaryColor3uivEXT', 'glSecondaryColor3usEXT',
'glSecondaryColor3usvEXT', 'glSecondaryColorPointerEXT',
'PFNGLSECONDARYCOLOR3BEXTPROC', 'PFNGLSECONDARYCOLOR3BVEXTPROC',
'PFNGLSECONDARYCOLOR3DEXTPROC', 'PFNGLSECONDARYCOLOR3DVEXTPROC',
'PFNGLSECONDARYCOLOR3FEXTPROC', 'PFNGLSECONDARYCOLOR3FVEXTPROC',
'PFNGLSECONDARYCOLOR3IEXTPROC', 'PFNGLSECONDARYCOLOR3IVEXTPROC',
'PFNGLSECONDARYCOLOR3SEXTPROC', 'PFNGLSECONDARYCOLOR3SVEXTPROC',
'PFNGLSECONDARYCOLOR3UBEXTPROC', 'PFNGLSECONDARYCOLOR3UBVEXTPROC',
'PFNGLSECONDARYCOLOR3UIEXTPROC', 'PFNGLSECONDARYCOLOR3UIVEXTPROC',
'PFNGLSECONDARYCOLOR3USEXTPROC', 'PFNGLSECONDARYCOLOR3USVEXTPROC',
'PFNGLSECONDARYCOLORPOINTEREXTPROC', 'GL_EXT_texture_perturb_normal',
'glTextureNormalEXT', 'PFNGLTEXTURENORMALEXTPROC', 'GL_EXT_multi_draw_arrays',
'glMultiDrawArraysEXT', 'glMultiDrawElementsEXT',
'PFNGLMULTIDRAWARRAYSEXTPROC', 'PFNGLMULTIDRAWELEMENTSEXTPROC',
'GL_EXT_fog_coord', 'glFogCoordfEXT', 'glFogCoordfvEXT', 'glFogCoorddEXT',
'glFogCoorddvEXT', 'glFogCoordPointerEXT', 'PFNGLFOGCOORDFEXTPROC',
'PFNGLFOGCOORDFVEXTPROC', 'PFNGLFOGCOORDDEXTPROC', 'PFNGLFOGCOORDDVEXTPROC',
'PFNGLFOGCOORDPOINTEREXTPROC', 'GL_REND_screen_coordinates',
'GL_EXT_coordinate_frame', 'glTangent3bEXT', 'glTangent3bvEXT',
'glTangent3dEXT', 'glTangent3dvEXT', 'glTangent3fEXT', 'glTangent3fvEXT',
'glTangent3iEXT', 'glTangent3ivEXT', 'glTangent3sEXT', 'glTangent3svEXT',
'glBinormal3bEXT', 'glBinormal3bvEXT', 'glBinormal3dEXT', 'glBinormal3dvEXT',
'glBinormal3fEXT', 'glBinormal3fvEXT', 'glBinormal3iEXT', 'glBinormal3ivEXT',
'glBinormal3sEXT', 'glBinormal3svEXT', 'glTangentPointerEXT',
'glBinormalPointerEXT', 'PFNGLTANGENT3BEXTPROC', 'PFNGLTANGENT3BVEXTPROC',
'PFNGLTANGENT3DEXTPROC', 'PFNGLTANGENT3DVEXTPROC', 'PFNGLTANGENT3FEXTPROC',
'PFNGLTANGENT3FVEXTPROC', 'PFNGLTANGENT3IEXTPROC', 'PFNGLTANGENT3IVEXTPROC',
'PFNGLTANGENT3SEXTPROC', 'PFNGLTANGENT3SVEXTPROC', 'PFNGLBINORMAL3BEXTPROC',
'PFNGLBINORMAL3BVEXTPROC', 'PFNGLBINORMAL3DEXTPROC',
'PFNGLBINORMAL3DVEXTPROC', 'PFNGLBINORMAL3FEXTPROC',
'PFNGLBINORMAL3FVEXTPROC', 'PFNGLBINORMAL3IEXTPROC',
'PFNGLBINORMAL3IVEXTPROC', 'PFNGLBINORMAL3SEXTPROC',
'PFNGLBINORMAL3SVEXTPROC', 'PFNGLTANGENTPOINTEREXTPROC',
'PFNGLBINORMALPOINTEREXTPROC', 'GL_EXT_texture_env_combine',
'GL_APPLE_specular_vector', 'GL_APPLE_transform_hint', 'GL_SGIX_fog_scale',
'GL_SUNX_constant_data', 'glFinishTextureSUNX', 'PFNGLFINISHTEXTURESUNXPROC',
'GL_SUN_global_alpha', 'glGlobalAlphaFactorbSUN', 'glGlobalAlphaFactorsSUN',
'glGlobalAlphaFactoriSUN', 'glGlobalAlphaFactorfSUN',
'glGlobalAlphaFactordSUN', 'glGlobalAlphaFactorubSUN',
'glGlobalAlphaFactorusSUN', 'glGlobalAlphaFactoruiSUN',
'PFNGLGLOBALALPHAFACTORBSUNPROC', 'PFNGLGLOBALALPHAFACTORSSUNPROC',
'PFNGLGLOBALALPHAFACTORISUNPROC', 'PFNGLGLOBALALPHAFACTORFSUNPROC',
'PFNGLGLOBALALPHAFACTORDSUNPROC', 'PFNGLGLOBALALPHAFACTORUBSUNPROC',
'PFNGLGLOBALALPHAFACTORUSSUNPROC', 'PFNGLGLOBALALPHAFACTORUISUNPROC',
'GL_SUN_triangle_list', 'glReplacementCodeuiSUN', 'glReplacementCodeusSUN',
'glReplacementCodeubSUN', 'glReplacementCodeuivSUN',
'glReplacementCodeusvSUN', 'glReplacementCodeubvSUN',
'glReplacementCodePointerSUN', 'PFNGLREPLACEMENTCODEUISUNPROC',
'PFNGLREPLACEMENTCODEUSSUNPROC', 'PFNGLREPLACEMENTCODEUBSUNPROC',
'PFNGLREPLACEMENTCODEUIVSUNPROC', 'PFNGLREPLACEMENTCODEUSVSUNPROC',
'PFNGLREPLACEMENTCODEUBVSUNPROC', 'PFNGLREPLACEMENTCODEPOINTERSUNPROC',
'GL_SUN_vertex', 'glColor4ubVertex2fSUN', 'glColor4ubVertex2fvSUN',
'glColor4ubVertex3fSUN', 'glColor4ubVertex3fvSUN', 'glColor3fVertex3fSUN',
'glColor3fVertex3fvSUN', 'glNormal3fVertex3fSUN', 'glNormal3fVertex3fvSUN',
'glColor4fNormal3fVertex3fSUN', 'glColor4fNormal3fVertex3fvSUN',
'glTexCoord2fVertex3fSUN', 'glTexCoord2fVertex3fvSUN',
'glTexCoord4fVertex4fSUN', 'glTexCoord4fVertex4fvSUN',
'glTexCoord2fColor4ubVertex3fSUN', 'glTexCoord2fColor4ubVertex3fvSUN',
'glTexCoord2fColor3fVertex3fSUN', 'glTexCoord2fColor3fVertex3fvSUN',
'glTexCoord2fNormal3fVertex3fSUN', 'glTexCoord2fNormal3fVertex3fvSUN',
'glTexCoord2fColor4fNormal3fVertex3fSUN',
'glTexCoord2fColor4fNormal3fVertex3fvSUN',
'glTexCoord4fColor4fNormal3fVertex4fSUN',
'glTexCoord4fColor4fNormal3fVertex4fvSUN', 'glReplacementCodeuiVertex3fSUN',
'glReplacementCodeuiVertex3fvSUN', 'glReplacementCodeuiColor4ubVertex3fSUN',
'glReplacementCodeuiColor4ubVertex3fvSUN',
'glReplacementCodeuiColor3fVertex3fSUN',
'glReplacementCodeuiColor3fVertex3fvSUN',
'glReplacementCodeuiNormal3fVertex3fSUN',
'glReplacementCodeuiNormal3fVertex3fvSUN',
'glReplacementCodeuiColor4fNormal3fVertex3fSUN',
'glReplacementCodeuiColor4fNormal3fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fVertex3fSUN',
'glReplacementCodeuiTexCoord2fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN',
'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN',
'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN',
'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN',
'PFNGLCOLOR4UBVERTEX2FSUNPROC', 'PFNGLCOLOR4UBVERTEX2FVSUNPROC',
'PFNGLCOLOR4UBVERTEX3FSUNPROC', 'PFNGLCOLOR4UBVERTEX3FVSUNPROC',
'PFNGLCOLOR3FVERTEX3FSUNPROC', 'PFNGLCOLOR3FVERTEX3FVSUNPROC',
'PFNGLNORMAL3FVERTEX3FSUNPROC', 'PFNGLNORMAL3FVERTEX3FVSUNPROC',
'PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC', 'PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FVERTEX3FSUNPROC', 'PFNGLTEXCOORD2FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD4FVERTEX4FSUNPROC', 'PFNGLTEXCOORD4FVERTEX4FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC',
'PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC',
'PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC',
'PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC',
'GL_EXT_blend_func_separate', 'glBlendFuncSeparateEXT',
'PFNGLBLENDFUNCSEPARATEEXTPROC', 'GL_INGR_blend_func_separate',
'glBlendFuncSeparateINGR', 'PFNGLBLENDFUNCSEPARATEINGRPROC',
'GL_INGR_color_clamp', 'GL_INGR_interlace_read', 'GL_EXT_stencil_wrap',
'GL_EXT_422_pixels', 'GL_NV_texgen_reflection',
'GL_SUN_convolution_border_modes', 'GL_EXT_texture_env_add',
'GL_EXT_texture_lod_bias', 'GL_EXT_texture_filter_anisotropic',
'GL_EXT_vertex_weighting', 'glVertexWeightfEXT', 'glVertexWeightfvEXT',
'glVertexWeightPointerEXT', 'PFNGLVERTEXWEIGHTFEXTPROC',
'PFNGLVERTEXWEIGHTFVEXTPROC', 'PFNGLVERTEXWEIGHTPOINTEREXTPROC',
'GL_NV_light_max_exponent', 'GL_NV_vertex_array_range',
'glFlushVertexArrayRangeNV', 'glVertexArrayRangeNV',
'PFNGLFLUSHVERTEXARRAYRANGENVPROC', 'PFNGLVERTEXARRAYRANGENVPROC',
'GL_NV_register_combiners', 'glCombinerParameterfvNV',
'glCombinerParameterfNV', 'glCombinerParameterivNV', 'glCombinerParameteriNV',
'glCombinerInputNV', 'glCombinerOutputNV', 'glFinalCombinerInputNV',
'glGetCombinerInputParameterfvNV', 'glGetCombinerInputParameterivNV',
'glGetCombinerOutputParameterfvNV', 'glGetCombinerOutputParameterivNV',
'glGetFinalCombinerInputParameterfvNV',
'glGetFinalCombinerInputParameterivNV', 'PFNGLCOMBINERPARAMETERFVNVPROC',
'PFNGLCOMBINERPARAMETERFNVPROC', 'PFNGLCOMBINERPARAMETERIVNVPROC',
'PFNGLCOMBINERPARAMETERINVPROC', 'PFNGLCOMBINERINPUTNVPROC',
'PFNGLCOMBINEROUTPUTNVPROC', 'PFNGLFINALCOMBINERINPUTNVPROC',
'PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC',
'PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC',
'PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC',
'PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC',
'PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC',
'PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC', 'GL_NV_fog_distance',
'GL_NV_texgen_emboss', 'GL_NV_blend_square', 'GL_NV_texture_env_combine4',
'GL_MESA_resize_buffers', 'glResizeBuffersMESA', 'PFNGLRESIZEBUFFERSMESAPROC',
'GL_MESA_window_pos', 'glWindowPos2dMESA', 'glWindowPos2dvMESA',
'glWindowPos2fMESA', 'glWindowPos2fvMESA', 'glWindowPos2iMESA',
'glWindowPos2ivMESA', 'glWindowPos2sMESA', 'glWindowPos2svMESA',
'glWindowPos3dMESA', 'glWindowPos3dvMESA', 'glWindowPos3fMESA',
'glWindowPos3fvMESA', 'glWindowPos3iMESA', 'glWindowPos3ivMESA',
'glWindowPos3sMESA', 'glWindowPos3svMESA', 'glWindowPos4dMESA',
'glWindowPos4dvMESA', 'glWindowPos4fMESA', 'glWindowPos4fvMESA',
'glWindowPos4iMESA', 'glWindowPos4ivMESA', 'glWindowPos4sMESA',
'glWindowPos4svMESA', 'PFNGLWINDOWPOS2DMESAPROC', 'PFNGLWINDOWPOS2DVMESAPROC',
'PFNGLWINDOWPOS2FMESAPROC', 'PFNGLWINDOWPOS2FVMESAPROC',
'PFNGLWINDOWPOS2IMESAPROC', 'PFNGLWINDOWPOS2IVMESAPROC',
'PFNGLWINDOWPOS2SMESAPROC', 'PFNGLWINDOWPOS2SVMESAPROC',
'PFNGLWINDOWPOS3DMESAPROC', 'PFNGLWINDOWPOS3DVMESAPROC',
'PFNGLWINDOWPOS3FMESAPROC', 'PFNGLWINDOWPOS3FVMESAPROC',
'PFNGLWINDOWPOS3IMESAPROC', 'PFNGLWINDOWPOS3IVMESAPROC',
'PFNGLWINDOWPOS3SMESAPROC', 'PFNGLWINDOWPOS3SVMESAPROC',
'PFNGLWINDOWPOS4DMESAPROC', 'PFNGLWINDOWPOS4DVMESAPROC',
'PFNGLWINDOWPOS4FMESAPROC', 'PFNGLWINDOWPOS4FVMESAPROC',
'PFNGLWINDOWPOS4IMESAPROC', 'PFNGLWINDOWPOS4IVMESAPROC',
'PFNGLWINDOWPOS4SMESAPROC', 'PFNGLWINDOWPOS4SVMESAPROC', 'GL_IBM_cull_vertex',
'GL_IBM_multimode_draw_arrays', 'glMultiModeDrawArraysIBM',
'glMultiModeDrawElementsIBM', 'PFNGLMULTIMODEDRAWARRAYSIBMPROC',
'PFNGLMULTIMODEDRAWELEMENTSIBMPROC', 'GL_IBM_vertex_array_lists',
'glColorPointerListIBM', 'glSecondaryColorPointerListIBM',
'glEdgeFlagPointerListIBM', 'glFogCoordPointerListIBM',
'glIndexPointerListIBM', 'glNormalPointerListIBM', 'glTexCoordPointerListIBM',
'glVertexPointerListIBM', 'PFNGLCOLORPOINTERLISTIBMPROC',
'PFNGLSECONDARYCOLORPOINTERLISTIBMPROC', 'PFNGLEDGEFLAGPOINTERLISTIBMPROC',
'PFNGLFOGCOORDPOINTERLISTIBMPROC', 'PFNGLINDEXPOINTERLISTIBMPROC',
'PFNGLNORMALPOINTERLISTIBMPROC', 'PFNGLTEXCOORDPOINTERLISTIBMPROC',
'PFNGLVERTEXPOINTERLISTIBMPROC', 'GL_SGIX_subsample', 'GL_SGIX_ycrcba',
'GL_SGIX_ycrcb_subsample', 'GL_SGIX_depth_pass_instrument',
'GL_3DFX_texture_compression_FXT1', 'GL_3DFX_multisample', 'GL_3DFX_tbuffer',
'glTbufferMask3DFX', 'PFNGLTBUFFERMASK3DFXPROC', 'GL_EXT_multisample',
'glSampleMaskEXT', 'glSamplePatternEXT', 'PFNGLSAMPLEMASKEXTPROC',
'PFNGLSAMPLEPATTERNEXTPROC', 'GL_SGIX_vertex_preclip',
'GL_SGIX_convolution_accuracy', 'GL_SGIX_resample',
'GL_SGIS_point_line_texgen', 'GL_SGIS_texture_color_mask',
'glTextureColorMaskSGIS', 'PFNGLTEXTURECOLORMASKSGISPROC',
'GL_SGIX_igloo_interface', 'glIglooInterfaceSGIX',
'PFNGLIGLOOINTERFACESGIXPROC', 'GL_EXT_texture_env_dot3',
'GL_ATI_texture_mirror_once', 'GL_NV_fence', 'glDeleteFencesNV',
'glGenFencesNV', 'glIsFenceNV', 'glTestFenceNV', 'glGetFenceivNV',
'glFinishFenceNV', 'glSetFenceNV', 'PFNGLDELETEFENCESNVPROC',
'PFNGLGENFENCESNVPROC', 'PFNGLISFENCENVPROC', 'PFNGLTESTFENCENVPROC',
'PFNGLGETFENCEIVNVPROC', 'PFNGLFINISHFENCENVPROC', 'PFNGLSETFENCENVPROC',
'GL_NV_evaluators', 'glMapControlPointsNV', 'glMapParameterivNV',
'glMapParameterfvNV', 'glGetMapControlPointsNV', 'glGetMapParameterivNV',
'glGetMapParameterfvNV', 'glGetMapAttribParameterivNV',
'glGetMapAttribParameterfvNV', 'glEvalMapsNV', 'PFNGLMAPCONTROLPOINTSNVPROC',
'PFNGLMAPPARAMETERIVNVPROC', 'PFNGLMAPPARAMETERFVNVPROC',
'PFNGLGETMAPCONTROLPOINTSNVPROC', 'PFNGLGETMAPPARAMETERIVNVPROC',
'PFNGLGETMAPPARAMETERFVNVPROC', 'PFNGLGETMAPATTRIBPARAMETERIVNVPROC',
'PFNGLGETMAPATTRIBPARAMETERFVNVPROC', 'PFNGLEVALMAPSNVPROC',
'GL_NV_packed_depth_stencil', 'GL_NV_register_combiners2',
'glCombinerStageParameterfvNV', 'glGetCombinerStageParameterfvNV',
'PFNGLCOMBINERSTAGEPARAMETERFVNVPROC',
'PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC', 'GL_NV_texture_compression_vtc',
'GL_NV_texture_rectangle', 'GL_NV_texture_shader', 'GL_NV_texture_shader2',
'GL_NV_vertex_array_range2', 'GL_NV_vertex_program',
'glAreProgramsResidentNV', 'glBindProgramNV', 'glDeleteProgramsNV',
'glExecuteProgramNV', 'glGenProgramsNV', 'glGetProgramParameterdvNV',
'glGetProgramParameterfvNV', 'glGetProgramivNV', 'glGetProgramStringNV',
'glGetTrackMatrixivNV', 'glGetVertexAttribdvNV', 'glGetVertexAttribfvNV',
'glGetVertexAttribivNV', 'glGetVertexAttribPointervNV', 'glIsProgramNV',
'glLoadProgramNV', 'glProgramParameter4dNV', 'glProgramParameter4dvNV',
'glProgramParameter4fNV', 'glProgramParameter4fvNV',
'glProgramParameters4dvNV', 'glProgramParameters4fvNV',
'glRequestResidentProgramsNV', 'glTrackMatrixNV', 'glVertexAttribPointerNV',
'glVertexAttrib1dNV', 'glVertexAttrib1dvNV', 'glVertexAttrib1fNV',
'glVertexAttrib1fvNV', 'glVertexAttrib1sNV', 'glVertexAttrib1svNV',
'glVertexAttrib2dNV', 'glVertexAttrib2dvNV', 'glVertexAttrib2fNV',
'glVertexAttrib2fvNV', 'glVertexAttrib2sNV', 'glVertexAttrib2svNV',
'glVertexAttrib3dNV', 'glVertexAttrib3dvNV', 'glVertexAttrib3fNV',
'glVertexAttrib3fvNV', 'glVertexAttrib3sNV', 'glVertexAttrib3svNV',
'glVertexAttrib4dNV', 'glVertexAttrib4dvNV', 'glVertexAttrib4fNV',
'glVertexAttrib4fvNV', 'glVertexAttrib4sNV', 'glVertexAttrib4svNV',
'glVertexAttrib4ubNV', 'glVertexAttrib4ubvNV', 'glVertexAttribs1dvNV',
'glVertexAttribs1fvNV', 'glVertexAttribs1svNV', 'glVertexAttribs2dvNV',
'glVertexAttribs2fvNV', 'glVertexAttribs2svNV', 'glVertexAttribs3dvNV',
'glVertexAttribs3fvNV', 'glVertexAttribs3svNV', 'glVertexAttribs4dvNV',
'glVertexAttribs4fvNV', 'glVertexAttribs4svNV', 'glVertexAttribs4ubvNV',
'PFNGLAREPROGRAMSRESIDENTNVPROC', 'PFNGLBINDPROGRAMNVPROC',
'PFNGLDELETEPROGRAMSNVPROC', 'PFNGLEXECUTEPROGRAMNVPROC',
'PFNGLGENPROGRAMSNVPROC', 'PFNGLGETPROGRAMPARAMETERDVNVPROC',
'PFNGLGETPROGRAMPARAMETERFVNVPROC', 'PFNGLGETPROGRAMIVNVPROC',
'PFNGLGETPROGRAMSTRINGNVPROC', 'PFNGLGETTRACKMATRIXIVNVPROC',
'PFNGLGETVERTEXATTRIBDVNVPROC', 'PFNGLGETVERTEXATTRIBFVNVPROC',
'PFNGLGETVERTEXATTRIBIVNVPROC', 'PFNGLGETVERTEXATTRIBPOINTERVNVPROC',
'PFNGLISPROGRAMNVPROC', 'PFNGLLOADPROGRAMNVPROC',
'PFNGLPROGRAMPARAMETER4DNVPROC', 'PFNGLPROGRAMPARAMETER4DVNVPROC',
'PFNGLPROGRAMPARAMETER4FNVPROC', 'PFNGLPROGRAMPARAMETER4FVNVPROC',
'PFNGLPROGRAMPARAMETERS4DVNVPROC', 'PFNGLPROGRAMPARAMETERS4FVNVPROC',
'PFNGLREQUESTRESIDENTPROGRAMSNVPROC', 'PFNGLTRACKMATRIXNVPROC',
'PFNGLVERTEXATTRIBPOINTERNVPROC', 'PFNGLVERTEXATTRIB1DNVPROC',
'PFNGLVERTEXATTRIB1DVNVPROC', 'PFNGLVERTEXATTRIB1FNVPROC',
'PFNGLVERTEXATTRIB1FVNVPROC', 'PFNGLVERTEXATTRIB1SNVPROC',
'PFNGLVERTEXATTRIB1SVNVPROC', 'PFNGLVERTEXATTRIB2DNVPROC',
'PFNGLVERTEXATTRIB2DVNVPROC', 'PFNGLVERTEXATTRIB2FNVPROC',
'PFNGLVERTEXATTRIB2FVNVPROC', 'PFNGLVERTEXATTRIB2SNVPROC',
'PFNGLVERTEXATTRIB2SVNVPROC', 'PFNGLVERTEXATTRIB3DNVPROC',
'PFNGLVERTEXATTRIB3DVNVPROC', 'PFNGLVERTEXATTRIB3FNVPROC',
'PFNGLVERTEXATTRIB3FVNVPROC', 'PFNGLVERTEXATTRIB3SNVPROC',
'PFNGLVERTEXATTRIB3SVNVPROC', 'PFNGLVERTEXATTRIB4DNVPROC',
'PFNGLVERTEXATTRIB4DVNVPROC', 'PFNGLVERTEXATTRIB4FNVPROC',
'PFNGLVERTEXATTRIB4FVNVPROC', 'PFNGLVERTEXATTRIB4SNVPROC',
'PFNGLVERTEXATTRIB4SVNVPROC', 'PFNGLVERTEXATTRIB4UBNVPROC',
'PFNGLVERTEXATTRIB4UBVNVPROC', 'PFNGLVERTEXATTRIBS1DVNVPROC',
'PFNGLVERTEXATTRIBS1FVNVPROC', 'PFNGLVERTEXATTRIBS1SVNVPROC',
'PFNGLVERTEXATTRIBS2DVNVPROC', 'PFNGLVERTEXATTRIBS2FVNVPROC',
'PFNGLVERTEXATTRIBS2SVNVPROC', 'PFNGLVERTEXATTRIBS3DVNVPROC',
'PFNGLVERTEXATTRIBS3FVNVPROC', 'PFNGLVERTEXATTRIBS3SVNVPROC',
'PFNGLVERTEXATTRIBS4DVNVPROC', 'PFNGLVERTEXATTRIBS4FVNVPROC',
'PFNGLVERTEXATTRIBS4SVNVPROC', 'PFNGLVERTEXATTRIBS4UBVNVPROC',
'GL_SGIX_texture_coordinate_clamp', 'GL_SGIX_scalebias_hint',
'GL_OML_interlace', 'GL_OML_subsample', 'GL_OML_resample',
'GL_NV_copy_depth_to_color', 'GL_ATI_envmap_bumpmap',
'glTexBumpParameterivATI', 'glTexBumpParameterfvATI',
'glGetTexBumpParameterivATI', 'glGetTexBumpParameterfvATI',
'PFNGLTEXBUMPPARAMETERIVATIPROC', 'PFNGLTEXBUMPPARAMETERFVATIPROC',
'PFNGLGETTEXBUMPPARAMETERIVATIPROC', 'PFNGLGETTEXBUMPPARAMETERFVATIPROC',
'GL_ATI_fragment_shader', 'glGenFragmentShadersATI',
'glBindFragmentShaderATI', 'glDeleteFragmentShaderATI',
'glBeginFragmentShaderATI', 'glEndFragmentShaderATI', 'glPassTexCoordATI',
'glSampleMapATI', 'glColorFragmentOp1ATI', 'glColorFragmentOp2ATI',
'glColorFragmentOp3ATI', 'glAlphaFragmentOp1ATI', 'glAlphaFragmentOp2ATI',
'glAlphaFragmentOp3ATI', 'glSetFragmentShaderConstantATI',
'PFNGLGENFRAGMENTSHADERSATIPROC', 'PFNGLBINDFRAGMENTSHADERATIPROC',
'PFNGLDELETEFRAGMENTSHADERATIPROC', 'PFNGLBEGINFRAGMENTSHADERATIPROC',
'PFNGLENDFRAGMENTSHADERATIPROC', 'PFNGLPASSTEXCOORDATIPROC',
'PFNGLSAMPLEMAPATIPROC', 'PFNGLCOLORFRAGMENTOP1ATIPROC',
'PFNGLCOLORFRAGMENTOP2ATIPROC', 'PFNGLCOLORFRAGMENTOP3ATIPROC',
'PFNGLALPHAFRAGMENTOP1ATIPROC', 'PFNGLALPHAFRAGMENTOP2ATIPROC',
'PFNGLALPHAFRAGMENTOP3ATIPROC', 'PFNGLSETFRAGMENTSHADERCONSTANTATIPROC',
'GL_ATI_pn_triangles', 'glPNTrianglesiATI', 'glPNTrianglesfATI',
'PFNGLPNTRIANGLESIATIPROC', 'PFNGLPNTRIANGLESFATIPROC',
'GL_ATI_vertex_array_object', 'glNewObjectBufferATI', 'glIsObjectBufferATI',
'glUpdateObjectBufferATI', 'glGetObjectBufferfvATI', 'glGetObjectBufferivATI',
'glFreeObjectBufferATI', 'glArrayObjectATI', 'glGetArrayObjectfvATI',
'glGetArrayObjectivATI', 'glVariantArrayObjectATI',
'glGetVariantArrayObjectfvATI', 'glGetVariantArrayObjectivATI',
'PFNGLNEWOBJECTBUFFERATIPROC', 'PFNGLISOBJECTBUFFERATIPROC',
'PFNGLUPDATEOBJECTBUFFERATIPROC', 'PFNGLGETOBJECTBUFFERFVATIPROC',
'PFNGLGETOBJECTBUFFERIVATIPROC', 'PFNGLFREEOBJECTBUFFERATIPROC',
'PFNGLARRAYOBJECTATIPROC', 'PFNGLGETARRAYOBJECTFVATIPROC',
'PFNGLGETARRAYOBJECTIVATIPROC', 'PFNGLVARIANTARRAYOBJECTATIPROC',
'PFNGLGETVARIANTARRAYOBJECTFVATIPROC', 'PFNGLGETVARIANTARRAYOBJECTIVATIPROC',
'GL_EXT_vertex_shader', 'glBeginVertexShaderEXT', 'glEndVertexShaderEXT',
'glBindVertexShaderEXT', 'glGenVertexShadersEXT', 'glDeleteVertexShaderEXT',
'glShaderOp1EXT', 'glShaderOp2EXT', 'glShaderOp3EXT', 'glSwizzleEXT',
'glWriteMaskEXT', 'glInsertComponentEXT', 'glExtractComponentEXT',
'glGenSymbolsEXT', 'glSetInvariantEXT', 'glSetLocalConstantEXT',
'glVariantbvEXT', 'glVariantsvEXT', 'glVariantivEXT', 'glVariantfvEXT',
'glVariantdvEXT', 'glVariantubvEXT', 'glVariantusvEXT', 'glVariantuivEXT',
'glVariantPointerEXT', 'glEnableVariantClientStateEXT',
'glDisableVariantClientStateEXT', 'glBindLightParameterEXT',
'glBindMaterialParameterEXT', 'glBindTexGenParameterEXT',
'glBindTextureUnitParameterEXT', 'glBindParameterEXT',
'glIsVariantEnabledEXT', 'glGetVariantBooleanvEXT', 'glGetVariantIntegervEXT',
'glGetVariantFloatvEXT', 'glGetVariantPointervEXT',
'glGetInvariantBooleanvEXT', 'glGetInvariantIntegervEXT',
'glGetInvariantFloatvEXT', 'glGetLocalConstantBooleanvEXT',
'glGetLocalConstantIntegervEXT', 'glGetLocalConstantFloatvEXT',
'PFNGLBEGINVERTEXSHADEREXTPROC', 'PFNGLENDVERTEXSHADEREXTPROC',
'PFNGLBINDVERTEXSHADEREXTPROC', 'PFNGLGENVERTEXSHADERSEXTPROC',
'PFNGLDELETEVERTEXSHADEREXTPROC', 'PFNGLSHADEROP1EXTPROC',
'PFNGLSHADEROP2EXTPROC', 'PFNGLSHADEROP3EXTPROC', 'PFNGLSWIZZLEEXTPROC',
'PFNGLWRITEMASKEXTPROC', 'PFNGLINSERTCOMPONENTEXTPROC',
'PFNGLEXTRACTCOMPONENTEXTPROC', 'PFNGLGENSYMBOLSEXTPROC',
'PFNGLSETINVARIANTEXTPROC', 'PFNGLSETLOCALCONSTANTEXTPROC',
'PFNGLVARIANTBVEXTPROC', 'PFNGLVARIANTSVEXTPROC', 'PFNGLVARIANTIVEXTPROC',
'PFNGLVARIANTFVEXTPROC', 'PFNGLVARIANTDVEXTPROC', 'PFNGLVARIANTUBVEXTPROC',
'PFNGLVARIANTUSVEXTPROC', 'PFNGLVARIANTUIVEXTPROC',
'PFNGLVARIANTPOINTEREXTPROC', 'PFNGLENABLEVARIANTCLIENTSTATEEXTPROC',
'PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC', 'PFNGLBINDLIGHTPARAMETEREXTPROC',
'PFNGLBINDMATERIALPARAMETEREXTPROC', 'PFNGLBINDTEXGENPARAMETEREXTPROC',
'PFNGLBINDTEXTUREUNITPARAMETEREXTPROC', 'PFNGLBINDPARAMETEREXTPROC',
'PFNGLISVARIANTENABLEDEXTPROC', 'PFNGLGETVARIANTBOOLEANVEXTPROC',
'PFNGLGETVARIANTINTEGERVEXTPROC', 'PFNGLGETVARIANTFLOATVEXTPROC',
'PFNGLGETVARIANTPOINTERVEXTPROC', 'PFNGLGETINVARIANTBOOLEANVEXTPROC',
'PFNGLGETINVARIANTINTEGERVEXTPROC', 'PFNGLGETINVARIANTFLOATVEXTPROC',
'PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC',
'PFNGLGETLOCALCONSTANTINTEGERVEXTPROC', 'PFNGLGETLOCALCONSTANTFLOATVEXTPROC',
'GL_ATI_vertex_streams', 'glVertexStream1sATI', 'glVertexStream1svATI',
'glVertexStream1iATI', 'glVertexStream1ivATI', 'glVertexStream1fATI',
'glVertexStream1fvATI', 'glVertexStream1dATI', 'glVertexStream1dvATI',
'glVertexStream2sATI', 'glVertexStream2svATI', 'glVertexStream2iATI',
'glVertexStream2ivATI', 'glVertexStream2fATI', 'glVertexStream2fvATI',
'glVertexStream2dATI', 'glVertexStream2dvATI', 'glVertexStream3sATI',
'glVertexStream3svATI', 'glVertexStream3iATI', 'glVertexStream3ivATI',
'glVertexStream3fATI', 'glVertexStream3fvATI', 'glVertexStream3dATI',
'glVertexStream3dvATI', 'glVertexStream4sATI', 'glVertexStream4svATI',
'glVertexStream4iATI', 'glVertexStream4ivATI', 'glVertexStream4fATI',
'glVertexStream4fvATI', 'glVertexStream4dATI', 'glVertexStream4dvATI',
'glNormalStream3bATI', 'glNormalStream3bvATI', 'glNormalStream3sATI',
'glNormalStream3svATI', 'glNormalStream3iATI', 'glNormalStream3ivATI',
'glNormalStream3fATI', 'glNormalStream3fvATI', 'glNormalStream3dATI',
'glNormalStream3dvATI', 'glClientActiveVertexStreamATI',
'glVertexBlendEnviATI', 'glVertexBlendEnvfATI', 'PFNGLVERTEXSTREAM1SATIPROC',
'PFNGLVERTEXSTREAM1SVATIPROC', 'PFNGLVERTEXSTREAM1IATIPROC',
'PFNGLVERTEXSTREAM1IVATIPROC', 'PFNGLVERTEXSTREAM1FATIPROC',
'PFNGLVERTEXSTREAM1FVATIPROC', 'PFNGLVERTEXSTREAM1DATIPROC',
'PFNGLVERTEXSTREAM1DVATIPROC', 'PFNGLVERTEXSTREAM2SATIPROC',
'PFNGLVERTEXSTREAM2SVATIPROC', 'PFNGLVERTEXSTREAM2IATIPROC',
'PFNGLVERTEXSTREAM2IVATIPROC', 'PFNGLVERTEXSTREAM2FATIPROC',
'PFNGLVERTEXSTREAM2FVATIPROC', 'PFNGLVERTEXSTREAM2DATIPROC',
'PFNGLVERTEXSTREAM2DVATIPROC', 'PFNGLVERTEXSTREAM3SATIPROC',
'PFNGLVERTEXSTREAM3SVATIPROC', 'PFNGLVERTEXSTREAM3IATIPROC',
'PFNGLVERTEXSTREAM3IVATIPROC', 'PFNGLVERTEXSTREAM3FATIPROC',
'PFNGLVERTEXSTREAM3FVATIPROC', 'PFNGLVERTEXSTREAM3DATIPROC',
'PFNGLVERTEXSTREAM3DVATIPROC', 'PFNGLVERTEXSTREAM4SATIPROC',
'PFNGLVERTEXSTREAM4SVATIPROC', 'PFNGLVERTEXSTREAM4IATIPROC',
'PFNGLVERTEXSTREAM4IVATIPROC', 'PFNGLVERTEXSTREAM4FATIPROC',
'PFNGLVERTEXSTREAM4FVATIPROC', 'PFNGLVERTEXSTREAM4DATIPROC',
'PFNGLVERTEXSTREAM4DVATIPROC', 'PFNGLNORMALSTREAM3BATIPROC',
'PFNGLNORMALSTREAM3BVATIPROC', 'PFNGLNORMALSTREAM3SATIPROC',
'PFNGLNORMALSTREAM3SVATIPROC', 'PFNGLNORMALSTREAM3IATIPROC',
'PFNGLNORMALSTREAM3IVATIPROC', 'PFNGLNORMALSTREAM3FATIPROC',
'PFNGLNORMALSTREAM3FVATIPROC', 'PFNGLNORMALSTREAM3DATIPROC',
'PFNGLNORMALSTREAM3DVATIPROC', 'PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC',
'PFNGLVERTEXBLENDENVIATIPROC', 'PFNGLVERTEXBLENDENVFATIPROC',
'GL_ATI_element_array', 'glElementPointerATI', 'glDrawElementArrayATI',
'glDrawRangeElementArrayATI', 'PFNGLELEMENTPOINTERATIPROC',
'PFNGLDRAWELEMENTARRAYATIPROC', 'PFNGLDRAWRANGEELEMENTARRAYATIPROC',
'GL_SUN_mesh_array', 'glDrawMeshArraysSUN', 'PFNGLDRAWMESHARRAYSSUNPROC',
'GL_SUN_slice_accum', 'GL_NV_multisample_filter_hint', 'GL_NV_depth_clamp',
'GL_NV_occlusion_query', 'glGenOcclusionQueriesNV',
'glDeleteOcclusionQueriesNV', 'glIsOcclusionQueryNV',
'glBeginOcclusionQueryNV', 'glEndOcclusionQueryNV', 'glGetOcclusionQueryivNV',
'glGetOcclusionQueryuivNV', 'PFNGLGENOCCLUSIONQUERIESNVPROC',
'PFNGLDELETEOCCLUSIONQUERIESNVPROC', 'PFNGLISOCCLUSIONQUERYNVPROC',
'PFNGLBEGINOCCLUSIONQUERYNVPROC', 'PFNGLENDOCCLUSIONQUERYNVPROC',
'PFNGLGETOCCLUSIONQUERYIVNVPROC', 'PFNGLGETOCCLUSIONQUERYUIVNVPROC',
'GL_NV_point_sprite', 'glPointParameteriNV', 'glPointParameterivNV',
'PFNGLPOINTPARAMETERINVPROC', 'PFNGLPOINTPARAMETERIVNVPROC',
'GL_NV_texture_shader3', 'GL_NV_vertex_program1_1', 'GL_EXT_shadow_funcs',
'GL_EXT_stencil_two_side', 'glActiveStencilFaceEXT',
'PFNGLACTIVESTENCILFACEEXTPROC', 'GL_ATI_text_fragment_shader',
'GL_APPLE_client_storage', 'GL_APPLE_element_array', 'glElementPointerAPPLE',
'glDrawElementArrayAPPLE', 'glDrawRangeElementArrayAPPLE',
'glMultiDrawElementArrayAPPLE', 'glMultiDrawRangeElementArrayAPPLE',
'PFNGLELEMENTPOINTERAPPLEPROC', 'PFNGLDRAWELEMENTARRAYAPPLEPROC',
'PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC', 'PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC',
'PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC', 'GL_APPLE_fence',
'glGenFencesAPPLE', 'glDeleteFencesAPPLE', 'glSetFenceAPPLE',
'glIsFenceAPPLE', 'glTestFenceAPPLE', 'glFinishFenceAPPLE',
'glTestObjectAPPLE', 'glFinishObjectAPPLE', 'PFNGLGENFENCESAPPLEPROC',
'PFNGLDELETEFENCESAPPLEPROC', 'PFNGLSETFENCEAPPLEPROC',
'PFNGLISFENCEAPPLEPROC', 'PFNGLTESTFENCEAPPLEPROC',
'PFNGLFINISHFENCEAPPLEPROC', 'PFNGLTESTOBJECTAPPLEPROC',
'PFNGLFINISHOBJECTAPPLEPROC', 'GL_APPLE_vertex_array_object',
'glBindVertexArrayAPPLE', 'glDeleteVertexArraysAPPLE',
'glGenVertexArraysAPPLE', 'glIsVertexArrayAPPLE',
'PFNGLBINDVERTEXARRAYAPPLEPROC', 'PFNGLDELETEVERTEXARRAYSAPPLEPROC',
'PFNGLGENVERTEXARRAYSAPPLEPROC', 'PFNGLISVERTEXARRAYAPPLEPROC',
'GL_APPLE_vertex_array_range', 'glVertexArrayRangeAPPLE',
'glFlushVertexArrayRangeAPPLE', 'glVertexArrayParameteriAPPLE',
'PFNGLVERTEXARRAYRANGEAPPLEPROC', 'PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC',
'PFNGLVERTEXARRAYPARAMETERIAPPLEPROC', 'GL_APPLE_ycbcr_422', 'GL_S3_s3tc',
'GL_ATI_draw_buffers', 'glDrawBuffersATI', 'PFNGLDRAWBUFFERSATIPROC',
'GL_ATI_pixel_format_float', 'GL_ATI_texture_env_combine3',
'GL_ATI_texture_float', 'GL_NV_float_buffer', 'GL_NV_fragment_program',
'glProgramNamedParameter4fNV', 'glProgramNamedParameter4dNV',
'glProgramNamedParameter4fvNV', 'glProgramNamedParameter4dvNV',
'glGetProgramNamedParameterfvNV', 'glGetProgramNamedParameterdvNV',
'PFNGLPROGRAMNAMEDPARAMETER4FNVPROC', 'PFNGLPROGRAMNAMEDPARAMETER4DNVPROC',
'PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC', 'PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC',
'PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC',
'PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC', 'GL_NV_half_float', 'glVertex2hNV',
'glVertex2hvNV', 'glVertex3hNV', 'glVertex3hvNV', 'glVertex4hNV',
'glVertex4hvNV', 'glNormal3hNV', 'glNormal3hvNV', 'glColor3hNV',
'glColor3hvNV', 'glColor4hNV', 'glColor4hvNV', 'glTexCoord1hNV',
'glTexCoord1hvNV', 'glTexCoord2hNV', 'glTexCoord2hvNV', 'glTexCoord3hNV',
'glTexCoord3hvNV', 'glTexCoord4hNV', 'glTexCoord4hvNV', 'glMultiTexCoord1hNV',
'glMultiTexCoord1hvNV', 'glMultiTexCoord2hNV', 'glMultiTexCoord2hvNV',
'glMultiTexCoord3hNV', 'glMultiTexCoord3hvNV', 'glMultiTexCoord4hNV',
'glMultiTexCoord4hvNV', 'glFogCoordhNV', 'glFogCoordhvNV',
'glSecondaryColor3hNV', 'glSecondaryColor3hvNV', 'glVertexWeighthNV',
'glVertexWeighthvNV', 'glVertexAttrib1hNV', 'glVertexAttrib1hvNV',
'glVertexAttrib2hNV', 'glVertexAttrib2hvNV', 'glVertexAttrib3hNV',
'glVertexAttrib3hvNV', 'glVertexAttrib4hNV', 'glVertexAttrib4hvNV',
'glVertexAttribs1hvNV', 'glVertexAttribs2hvNV', 'glVertexAttribs3hvNV',
'glVertexAttribs4hvNV', 'PFNGLVERTEX2HNVPROC', 'PFNGLVERTEX2HVNVPROC',
'PFNGLVERTEX3HNVPROC', 'PFNGLVERTEX3HVNVPROC', 'PFNGLVERTEX4HNVPROC',
'PFNGLVERTEX4HVNVPROC', 'PFNGLNORMAL3HNVPROC', 'PFNGLNORMAL3HVNVPROC',
'PFNGLCOLOR3HNVPROC', 'PFNGLCOLOR3HVNVPROC', 'PFNGLCOLOR4HNVPROC',
'PFNGLCOLOR4HVNVPROC', 'PFNGLTEXCOORD1HNVPROC', 'PFNGLTEXCOORD1HVNVPROC',
'PFNGLTEXCOORD2HNVPROC', 'PFNGLTEXCOORD2HVNVPROC', 'PFNGLTEXCOORD3HNVPROC',
'PFNGLTEXCOORD3HVNVPROC', 'PFNGLTEXCOORD4HNVPROC', 'PFNGLTEXCOORD4HVNVPROC',
'PFNGLMULTITEXCOORD1HNVPROC', 'PFNGLMULTITEXCOORD1HVNVPROC',
'PFNGLMULTITEXCOORD2HNVPROC', 'PFNGLMULTITEXCOORD2HVNVPROC',
'PFNGLMULTITEXCOORD3HNVPROC', 'PFNGLMULTITEXCOORD3HVNVPROC',
'PFNGLMULTITEXCOORD4HNVPROC', 'PFNGLMULTITEXCOORD4HVNVPROC',
'PFNGLFOGCOORDHNVPROC', 'PFNGLFOGCOORDHVNVPROC',
'PFNGLSECONDARYCOLOR3HNVPROC', 'PFNGLSECONDARYCOLOR3HVNVPROC',
'PFNGLVERTEXWEIGHTHNVPROC', 'PFNGLVERTEXWEIGHTHVNVPROC',
'PFNGLVERTEXATTRIB1HNVPROC', 'PFNGLVERTEXATTRIB1HVNVPROC',
'PFNGLVERTEXATTRIB2HNVPROC', 'PFNGLVERTEXATTRIB2HVNVPROC',
'PFNGLVERTEXATTRIB3HNVPROC', 'PFNGLVERTEXATTRIB3HVNVPROC',
'PFNGLVERTEXATTRIB4HNVPROC', 'PFNGLVERTEXATTRIB4HVNVPROC',
'PFNGLVERTEXATTRIBS1HVNVPROC', 'PFNGLVERTEXATTRIBS2HVNVPROC',
'PFNGLVERTEXATTRIBS3HVNVPROC', 'PFNGLVERTEXATTRIBS4HVNVPROC',
'GL_NV_pixel_data_range', 'glPixelDataRangeNV', 'glFlushPixelDataRangeNV',
'PFNGLPIXELDATARANGENVPROC', 'PFNGLFLUSHPIXELDATARANGENVPROC',
'GL_NV_primitive_restart', 'glPrimitiveRestartNV',
'glPrimitiveRestartIndexNV', 'PFNGLPRIMITIVERESTARTNVPROC',
'PFNGLPRIMITIVERESTARTINDEXNVPROC', 'GL_NV_texture_expand_normal',
'GL_NV_vertex_program2', 'GL_ATI_map_object_buffer', 'glMapObjectBufferATI',
'glUnmapObjectBufferATI', 'PFNGLMAPOBJECTBUFFERATIPROC',
'PFNGLUNMAPOBJECTBUFFERATIPROC', 'GL_ATI_separate_stencil',
'glStencilOpSeparateATI', 'glStencilFuncSeparateATI',
'PFNGLSTENCILOPSEPARATEATIPROC', 'PFNGLSTENCILFUNCSEPARATEATIPROC',
'GL_ATI_vertex_attrib_array_object', 'glVertexAttribArrayObjectATI',
'glGetVertexAttribArrayObjectfvATI', 'glGetVertexAttribArrayObjectivATI',
'PFNGLVERTEXATTRIBARRAYOBJECTATIPROC',
'PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC',
'PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC', 'GL_OES_read_format',
'GL_EXT_depth_bounds_test', 'glDepthBoundsEXT', 'PFNGLDEPTHBOUNDSEXTPROC',
'GL_EXT_texture_mirror_clamp', 'GL_EXT_blend_equation_separate',
'glBlendEquationSeparateEXT', 'PFNGLBLENDEQUATIONSEPARATEEXTPROC',
'GL_MESA_pack_invert', 'GL_MESA_ycbcr_texture', 'GL_EXT_pixel_buffer_object',
'GL_NV_fragment_program_option', 'GL_NV_fragment_program2',
'GL_NV_vertex_program2_option', 'GL_NV_vertex_program3',
'GL_EXT_framebuffer_object', 'glIsRenderbufferEXT', 'glBindRenderbufferEXT',
'glDeleteRenderbuffersEXT', 'glGenRenderbuffersEXT',
'glRenderbufferStorageEXT', 'glGetRenderbufferParameterivEXT',
'glIsFramebufferEXT', 'glBindFramebufferEXT', 'glDeleteFramebuffersEXT',
'glGenFramebuffersEXT', 'glCheckFramebufferStatusEXT',
'glFramebufferTexture1DEXT', 'glFramebufferTexture2DEXT',
'glFramebufferTexture3DEXT', 'glFramebufferRenderbufferEXT',
'glGetFramebufferAttachmentParameterivEXT', 'glGenerateMipmapEXT',
'PFNGLISRENDERBUFFEREXTPROC', 'PFNGLBINDRENDERBUFFEREXTPROC',
'PFNGLDELETERENDERBUFFERSEXTPROC', 'PFNGLGENRENDERBUFFERSEXTPROC',
'PFNGLRENDERBUFFERSTORAGEEXTPROC', 'PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC',
'PFNGLISFRAMEBUFFEREXTPROC', 'PFNGLBINDFRAMEBUFFEREXTPROC',
'PFNGLDELETEFRAMEBUFFERSEXTPROC', 'PFNGLGENFRAMEBUFFERSEXTPROC',
'PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC', 'PFNGLFRAMEBUFFERTEXTURE1DEXTPROC',
'PFNGLFRAMEBUFFERTEXTURE2DEXTPROC', 'PFNGLFRAMEBUFFERTEXTURE3DEXTPROC',
'PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC',
'PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC',
'PFNGLGENERATEMIPMAPEXTPROC', 'GL_GREMEDY_string_marker',
'glStringMarkerGREMEDY', 'PFNGLSTRINGMARKERGREMEDYPROC',
'GL_EXT_packed_depth_stencil', 'GL_EXT_stencil_clear_tag',
'glStencilClearTagEXT', 'PFNGLSTENCILCLEARTAGEXTPROC', 'GL_EXT_texture_sRGB',
'GL_EXT_framebuffer_blit', 'glBlitFramebufferEXT',
'PFNGLBLITFRAMEBUFFEREXTPROC', 'GL_EXT_framebuffer_multisample',
'glRenderbufferStorageMultisampleEXT',
'PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC', 'GL_MESAX_texture_stack',
'GL_EXT_timer_query', 'glGetQueryObjecti64vEXT', 'glGetQueryObjectui64vEXT',
'PFNGLGETQUERYOBJECTI64VEXTPROC', 'PFNGLGETQUERYOBJECTUI64VEXTPROC',
'GL_EXT_gpu_program_parameters', 'glProgramEnvParameters4fvEXT',
'glProgramLocalParameters4fvEXT', 'PFNGLPROGRAMENVPARAMETERS4FVEXTPROC',
'PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC', 'GL_APPLE_flush_buffer_range',
'glBufferParameteriAPPLE', 'glFlushMappedBufferRangeAPPLE',
'PFNGLBUFFERPARAMETERIAPPLEPROC', 'PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC',
'GL_NV_gpu_program4', 'glProgramLocalParameterI4iNV',
'glProgramLocalParameterI4ivNV', 'glProgramLocalParametersI4ivNV',
'glProgramLocalParameterI4uiNV', 'glProgramLocalParameterI4uivNV',
'glProgramLocalParametersI4uivNV', 'glProgramEnvParameterI4iNV',
'glProgramEnvParameterI4ivNV', 'glProgramEnvParametersI4ivNV',
'glProgramEnvParameterI4uiNV', 'glProgramEnvParameterI4uivNV',
'glProgramEnvParametersI4uivNV', 'glGetProgramLocalParameterIivNV',
'glGetProgramLocalParameterIuivNV', 'glGetProgramEnvParameterIivNV',
'glGetProgramEnvParameterIuivNV', 'PFNGLPROGRAMLOCALPARAMETERI4INVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4UINVPROC',
'PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC',
'PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC', 'PFNGLPROGRAMENVPARAMETERI4INVPROC',
'PFNGLPROGRAMENVPARAMETERI4IVNVPROC', 'PFNGLPROGRAMENVPARAMETERSI4IVNVPROC',
'PFNGLPROGRAMENVPARAMETERI4UINVPROC', 'PFNGLPROGRAMENVPARAMETERI4UIVNVPROC',
'PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC',
'PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC',
'PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC',
'PFNGLGETPROGRAMENVPARAMETERIIVNVPROC',
'PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC', 'GL_NV_geometry_program4',
'glProgramVertexLimitNV', 'glFramebufferTextureEXT',
'glFramebufferTextureLayerEXT', 'glFramebufferTextureFaceEXT',
'PFNGLPROGRAMVERTEXLIMITNVPROC', 'PFNGLFRAMEBUFFERTEXTUREEXTPROC',
'PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC', 'PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC',
'GL_EXT_geometry_shader4', 'glProgramParameteriEXT',
'PFNGLPROGRAMPARAMETERIEXTPROC', 'GL_NV_vertex_program4',
'glVertexAttribI1iEXT', 'glVertexAttribI2iEXT', 'glVertexAttribI3iEXT',
'glVertexAttribI4iEXT', 'glVertexAttribI1uiEXT', 'glVertexAttribI2uiEXT',
'glVertexAttribI3uiEXT', 'glVertexAttribI4uiEXT', 'glVertexAttribI1ivEXT',
'glVertexAttribI2ivEXT', 'glVertexAttribI3ivEXT', 'glVertexAttribI4ivEXT',
'glVertexAttribI1uivEXT', 'glVertexAttribI2uivEXT', 'glVertexAttribI3uivEXT',
'glVertexAttribI4uivEXT', 'glVertexAttribI4bvEXT', 'glVertexAttribI4svEXT',
'glVertexAttribI4ubvEXT', 'glVertexAttribI4usvEXT',
'glVertexAttribIPointerEXT', 'glGetVertexAttribIivEXT',
'glGetVertexAttribIuivEXT', 'PFNGLVERTEXATTRIBI1IEXTPROC',
'PFNGLVERTEXATTRIBI2IEXTPROC', 'PFNGLVERTEXATTRIBI3IEXTPROC',
'PFNGLVERTEXATTRIBI4IEXTPROC', 'PFNGLVERTEXATTRIBI1UIEXTPROC',
'PFNGLVERTEXATTRIBI2UIEXTPROC', 'PFNGLVERTEXATTRIBI3UIEXTPROC',
'PFNGLVERTEXATTRIBI4UIEXTPROC', 'PFNGLVERTEXATTRIBI1IVEXTPROC',
'PFNGLVERTEXATTRIBI2IVEXTPROC', 'PFNGLVERTEXATTRIBI3IVEXTPROC',
'PFNGLVERTEXATTRIBI4IVEXTPROC', 'PFNGLVERTEXATTRIBI1UIVEXTPROC',
'PFNGLVERTEXATTRIBI2UIVEXTPROC', 'PFNGLVERTEXATTRIBI3UIVEXTPROC',
'PFNGLVERTEXATTRIBI4UIVEXTPROC', 'PFNGLVERTEXATTRIBI4BVEXTPROC',
'PFNGLVERTEXATTRIBI4SVEXTPROC', 'PFNGLVERTEXATTRIBI4UBVEXTPROC',
'PFNGLVERTEXATTRIBI4USVEXTPROC', 'PFNGLVERTEXATTRIBIPOINTEREXTPROC',
'PFNGLGETVERTEXATTRIBIIVEXTPROC', 'PFNGLGETVERTEXATTRIBIUIVEXTPROC',
'GL_EXT_gpu_shader4', 'glGetUniformuivEXT', 'glBindFragDataLocationEXT',
'glGetFragDataLocationEXT', 'glUniform1uiEXT', 'glUniform2uiEXT',
'glUniform3uiEXT', 'glUniform4uiEXT', 'glUniform1uivEXT', 'glUniform2uivEXT',
'glUniform3uivEXT', 'glUniform4uivEXT', 'PFNGLGETUNIFORMUIVEXTPROC',
'PFNGLBINDFRAGDATALOCATIONEXTPROC', 'PFNGLGETFRAGDATALOCATIONEXTPROC',
'PFNGLUNIFORM1UIEXTPROC', 'PFNGLUNIFORM2UIEXTPROC', 'PFNGLUNIFORM3UIEXTPROC',
'PFNGLUNIFORM4UIEXTPROC', 'PFNGLUNIFORM1UIVEXTPROC',
'PFNGLUNIFORM2UIVEXTPROC', 'PFNGLUNIFORM3UIVEXTPROC',
'PFNGLUNIFORM4UIVEXTPROC', 'GL_EXT_draw_instanced',
'glDrawArraysInstancedEXT', 'glDrawElementsInstancedEXT',
'PFNGLDRAWARRAYSINSTANCEDEXTPROC', 'PFNGLDRAWELEMENTSINSTANCEDEXTPROC',
'GL_EXT_packed_float', 'GL_EXT_texture_array', 'GL_EXT_texture_buffer_object',
'glTexBufferEXT', 'PFNGLTEXBUFFEREXTPROC', 'GL_EXT_texture_compression_latc',
'GL_EXT_texture_compression_rgtc', 'GL_EXT_texture_shared_exponent',
'GL_NV_depth_buffer_float', 'glDepthRangedNV', 'glClearDepthdNV',
'glDepthBoundsdNV', 'PFNGLDEPTHRANGEDNVPROC', 'PFNGLCLEARDEPTHDNVPROC',
'PFNGLDEPTHBOUNDSDNVPROC', 'GL_NV_fragment_program4',
'GL_NV_framebuffer_multisample_coverage',
'glRenderbufferStorageMultisampleCoverageNV',
'PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC',
'GL_EXT_framebuffer_sRGB', 'GL_NV_geometry_shader4',
'GL_NV_parameter_buffer_object', 'glProgramBufferParametersfvNV',
'glProgramBufferParametersIivNV', 'glProgramBufferParametersIuivNV',
'PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC',
'PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC',
'PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC', 'GL_EXT_draw_buffers2',
'glColorMaskIndexedEXT', 'glGetBooleanIndexedvEXT', 'glGetIntegerIndexedvEXT',
'glEnableIndexedEXT', 'glDisableIndexedEXT', 'glIsEnabledIndexedEXT',
'PFNGLCOLORMASKINDEXEDEXTPROC', 'PFNGLGETBOOLEANINDEXEDVEXTPROC',
'PFNGLGETINTEGERINDEXEDVEXTPROC', 'PFNGLENABLEINDEXEDEXTPROC',
'PFNGLDISABLEINDEXEDEXTPROC', 'PFNGLISENABLEDINDEXEDEXTPROC',
'GL_NV_transform_feedback', 'glBeginTransformFeedbackNV',
'glEndTransformFeedbackNV', 'glTransformFeedbackAttribsNV',
'glBindBufferRangeNV', 'glBindBufferOffsetNV', 'glBindBufferBaseNV',
'glTransformFeedbackVaryingsNV', 'glActiveVaryingNV',
'glGetVaryingLocationNV', 'glGetActiveVaryingNV',
'glGetTransformFeedbackVaryingNV', 'glTransformFeedbackStreamAttribsNV',
'PFNGLBEGINTRANSFORMFEEDBACKNVPROC', 'PFNGLENDTRANSFORMFEEDBACKNVPROC',
'PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC', 'PFNGLBINDBUFFERRANGENVPROC',
'PFNGLBINDBUFFEROFFSETNVPROC', 'PFNGLBINDBUFFERBASENVPROC',
'PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC', 'PFNGLACTIVEVARYINGNVPROC',
'PFNGLGETVARYINGLOCATIONNVPROC', 'PFNGLGETACTIVEVARYINGNVPROC',
'PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC',
'PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC', 'GL_EXT_bindable_uniform',
'glUniformBufferEXT', 'glGetUniformBufferSizeEXT', 'glGetUniformOffsetEXT',
'PFNGLUNIFORMBUFFEREXTPROC', 'PFNGLGETUNIFORMBUFFERSIZEEXTPROC',
'PFNGLGETUNIFORMOFFSETEXTPROC', 'GL_EXT_texture_integer',
'glTexParameterIivEXT', 'glTexParameterIuivEXT', 'glGetTexParameterIivEXT',
'glGetTexParameterIuivEXT', 'glClearColorIiEXT', 'glClearColorIuiEXT',
'PFNGLTEXPARAMETERIIVEXTPROC', 'PFNGLTEXPARAMETERIUIVEXTPROC',
'PFNGLGETTEXPARAMETERIIVEXTPROC', 'PFNGLGETTEXPARAMETERIUIVEXTPROC',
'PFNGLCLEARCOLORIIEXTPROC', 'PFNGLCLEARCOLORIUIEXTPROC',
'GL_GREMEDY_frame_terminator', 'glFrameTerminatorGREMEDY',
'PFNGLFRAMETERMINATORGREMEDYPROC', 'GL_NV_conditional_render',
'glBeginConditionalRenderNV', 'glEndConditionalRenderNV',
'PFNGLBEGINCONDITIONALRENDERNVPROC', 'PFNGLENDCONDITIONALRENDERNVPROC',
'GL_NV_present_video', 'glPresentFrameKeyedNV', 'glPresentFrameDualFillNV',
'glGetVideoivNV', 'glGetVideouivNV', 'glGetVideoi64vNV', 'glGetVideoui64vNV',
'PFNGLPRESENTFRAMEKEYEDNVPROC', 'PFNGLPRESENTFRAMEDUALFILLNVPROC',
'PFNGLGETVIDEOIVNVPROC', 'PFNGLGETVIDEOUIVNVPROC', 'PFNGLGETVIDEOI64VNVPROC',
'PFNGLGETVIDEOUI64VNVPROC', 'GL_EXT_transform_feedback',
'glBeginTransformFeedbackEXT', 'glEndTransformFeedbackEXT',
'glBindBufferRangeEXT', 'glBindBufferOffsetEXT', 'glBindBufferBaseEXT',
'glTransformFeedbackVaryingsEXT', 'glGetTransformFeedbackVaryingEXT',
'PFNGLBEGINTRANSFORMFEEDBACKEXTPROC', 'PFNGLENDTRANSFORMFEEDBACKEXTPROC',
'PFNGLBINDBUFFERRANGEEXTPROC', 'PFNGLBINDBUFFEROFFSETEXTPROC',
'PFNGLBINDBUFFERBASEEXTPROC', 'PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC',
'PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC', 'GL_EXT_direct_state_access',
'glClientAttribDefaultEXT', 'glPushClientAttribDefaultEXT',
'glMatrixLoadfEXT', 'glMatrixLoaddEXT', 'glMatrixMultfEXT',
'glMatrixMultdEXT', 'glMatrixLoadIdentityEXT', 'glMatrixRotatefEXT',
'glMatrixRotatedEXT', 'glMatrixScalefEXT', 'glMatrixScaledEXT',
'glMatrixTranslatefEXT', 'glMatrixTranslatedEXT', 'glMatrixFrustumEXT',
'glMatrixOrthoEXT', 'glMatrixPopEXT', 'glMatrixPushEXT',
'glMatrixLoadTransposefEXT', 'glMatrixLoadTransposedEXT',
'glMatrixMultTransposefEXT', 'glMatrixMultTransposedEXT',
'glTextureParameterfEXT', 'glTextureParameterfvEXT', 'glTextureParameteriEXT',
'glTextureParameterivEXT', 'glTextureImage1DEXT', 'glTextureImage2DEXT',
'glTextureSubImage1DEXT', 'glTextureSubImage2DEXT', 'glCopyTextureImage1DEXT',
'glCopyTextureImage2DEXT', 'glCopyTextureSubImage1DEXT',
'glCopyTextureSubImage2DEXT', 'glGetTextureImageEXT',
'glGetTextureParameterfvEXT', 'glGetTextureParameterivEXT',
'glGetTextureLevelParameterfvEXT', 'glGetTextureLevelParameterivEXT',
'glTextureImage3DEXT', 'glTextureSubImage3DEXT', 'glCopyTextureSubImage3DEXT',
'glMultiTexParameterfEXT', 'glMultiTexParameterfvEXT',
'glMultiTexParameteriEXT', 'glMultiTexParameterivEXT', 'glMultiTexImage1DEXT',
'glMultiTexImage2DEXT', 'glMultiTexSubImage1DEXT', 'glMultiTexSubImage2DEXT',
'glCopyMultiTexImage1DEXT', 'glCopyMultiTexImage2DEXT',
'glCopyMultiTexSubImage1DEXT', 'glCopyMultiTexSubImage2DEXT',
'glGetMultiTexImageEXT', 'glGetMultiTexParameterfvEXT',
'glGetMultiTexParameterivEXT', 'glGetMultiTexLevelParameterfvEXT',
'glGetMultiTexLevelParameterivEXT', 'glMultiTexImage3DEXT',
'glMultiTexSubImage3DEXT', 'glCopyMultiTexSubImage3DEXT',
'glBindMultiTextureEXT', 'glEnableClientStateIndexedEXT',
'glDisableClientStateIndexedEXT', 'glMultiTexCoordPointerEXT',
'glMultiTexEnvfEXT', 'glMultiTexEnvfvEXT', 'glMultiTexEnviEXT',
'glMultiTexEnvivEXT', 'glMultiTexGendEXT', 'glMultiTexGendvEXT',
'glMultiTexGenfEXT', 'glMultiTexGenfvEXT', 'glMultiTexGeniEXT',
'glMultiTexGenivEXT', 'glGetMultiTexEnvfvEXT', 'glGetMultiTexEnvivEXT',
'glGetMultiTexGendvEXT', 'glGetMultiTexGenfvEXT', 'glGetMultiTexGenivEXT',
'glGetFloatIndexedvEXT', 'glGetDoubleIndexedvEXT', 'glGetPointerIndexedvEXT',
'glCompressedTextureImage3DEXT', 'glCompressedTextureImage2DEXT',
'glCompressedTextureImage1DEXT', 'glCompressedTextureSubImage3DEXT',
'glCompressedTextureSubImage2DEXT', 'glCompressedTextureSubImage1DEXT',
'glGetCompressedTextureImageEXT', 'glCompressedMultiTexImage3DEXT',
'glCompressedMultiTexImage2DEXT', 'glCompressedMultiTexImage1DEXT',
'glCompressedMultiTexSubImage3DEXT', 'glCompressedMultiTexSubImage2DEXT',
'glCompressedMultiTexSubImage1DEXT', 'glGetCompressedMultiTexImageEXT',
'glNamedProgramStringEXT', 'glNamedProgramLocalParameter4dEXT',
'glNamedProgramLocalParameter4dvEXT', 'glNamedProgramLocalParameter4fEXT',
'glNamedProgramLocalParameter4fvEXT', 'glGetNamedProgramLocalParameterdvEXT',
'glGetNamedProgramLocalParameterfvEXT', 'glGetNamedProgramivEXT',
'glGetNamedProgramStringEXT', 'glNamedProgramLocalParameters4fvEXT',
'glNamedProgramLocalParameterI4iEXT', 'glNamedProgramLocalParameterI4ivEXT',
'glNamedProgramLocalParametersI4ivEXT', 'glNamedProgramLocalParameterI4uiEXT',
'glNamedProgramLocalParameterI4uivEXT',
'glNamedProgramLocalParametersI4uivEXT',
'glGetNamedProgramLocalParameterIivEXT',
'glGetNamedProgramLocalParameterIuivEXT', 'glTextureParameterIivEXT',
'glTextureParameterIuivEXT', 'glGetTextureParameterIivEXT',
'glGetTextureParameterIuivEXT', 'glMultiTexParameterIivEXT',
'glMultiTexParameterIuivEXT', 'glGetMultiTexParameterIivEXT',
'glGetMultiTexParameterIuivEXT', 'glProgramUniform1fEXT',
'glProgramUniform2fEXT', 'glProgramUniform3fEXT', 'glProgramUniform4fEXT',
'glProgramUniform1iEXT', 'glProgramUniform2iEXT', 'glProgramUniform3iEXT',
'glProgramUniform4iEXT', 'glProgramUniform1fvEXT', 'glProgramUniform2fvEXT',
'glProgramUniform3fvEXT', 'glProgramUniform4fvEXT', 'glProgramUniform1ivEXT',
'glProgramUniform2ivEXT', 'glProgramUniform3ivEXT', 'glProgramUniform4ivEXT',
'glProgramUniformMatrix2fvEXT', 'glProgramUniformMatrix3fvEXT',
'glProgramUniformMatrix4fvEXT', 'glProgramUniformMatrix2x3fvEXT',
'glProgramUniformMatrix3x2fvEXT', 'glProgramUniformMatrix2x4fvEXT',
'glProgramUniformMatrix4x2fvEXT', 'glProgramUniformMatrix3x4fvEXT',
'glProgramUniformMatrix4x3fvEXT', 'glProgramUniform1uiEXT',
'glProgramUniform2uiEXT', 'glProgramUniform3uiEXT', 'glProgramUniform4uiEXT',
'glProgramUniform1uivEXT', 'glProgramUniform2uivEXT',
'glProgramUniform3uivEXT', 'glProgramUniform4uivEXT', 'glNamedBufferDataEXT',
'glNamedBufferSubDataEXT', 'glMapNamedBufferEXT', 'glUnmapNamedBufferEXT',
'glMapNamedBufferRangeEXT', 'glFlushMappedNamedBufferRangeEXT',
'glNamedCopyBufferSubDataEXT', 'glGetNamedBufferParameterivEXT',
'glGetNamedBufferPointervEXT', 'glGetNamedBufferSubDataEXT',
'glTextureBufferEXT', 'glMultiTexBufferEXT', 'glNamedRenderbufferStorageEXT',
'glGetNamedRenderbufferParameterivEXT', 'glCheckNamedFramebufferStatusEXT',
'glNamedFramebufferTexture1DEXT', 'glNamedFramebufferTexture2DEXT',
'glNamedFramebufferTexture3DEXT', 'glNamedFramebufferRenderbufferEXT',
'glGetNamedFramebufferAttachmentParameterivEXT', 'glGenerateTextureMipmapEXT',
'glGenerateMultiTexMipmapEXT', 'glFramebufferDrawBufferEXT',
'glFramebufferDrawBuffersEXT', 'glFramebufferReadBufferEXT',
'glGetFramebufferParameterivEXT', 'glNamedRenderbufferStorageMultisampleEXT',
'glNamedRenderbufferStorageMultisampleCoverageEXT',
'glNamedFramebufferTextureEXT', 'glNamedFramebufferTextureLayerEXT',
'glNamedFramebufferTextureFaceEXT', 'glTextureRenderbufferEXT',
'glMultiTexRenderbufferEXT', 'glProgramUniform1dEXT', 'glProgramUniform2dEXT',
'glProgramUniform3dEXT', 'glProgramUniform4dEXT', 'glProgramUniform1dvEXT',
'glProgramUniform2dvEXT', 'glProgramUniform3dvEXT', 'glProgramUniform4dvEXT',
'glProgramUniformMatrix2dvEXT', 'glProgramUniformMatrix3dvEXT',
'glProgramUniformMatrix4dvEXT', 'glProgramUniformMatrix2x3dvEXT',
'glProgramUniformMatrix2x4dvEXT', 'glProgramUniformMatrix3x2dvEXT',
'glProgramUniformMatrix3x4dvEXT', 'glProgramUniformMatrix4x2dvEXT',
'glProgramUniformMatrix4x3dvEXT', 'PFNGLCLIENTATTRIBDEFAULTEXTPROC',
'PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC', 'PFNGLMATRIXLOADFEXTPROC',
'PFNGLMATRIXLOADDEXTPROC', 'PFNGLMATRIXMULTFEXTPROC',
'PFNGLMATRIXMULTDEXTPROC', 'PFNGLMATRIXLOADIDENTITYEXTPROC',
'PFNGLMATRIXROTATEFEXTPROC', 'PFNGLMATRIXROTATEDEXTPROC',
'PFNGLMATRIXSCALEFEXTPROC', 'PFNGLMATRIXSCALEDEXTPROC',
'PFNGLMATRIXTRANSLATEFEXTPROC', 'PFNGLMATRIXTRANSLATEDEXTPROC',
'PFNGLMATRIXFRUSTUMEXTPROC', 'PFNGLMATRIXORTHOEXTPROC',
'PFNGLMATRIXPOPEXTPROC', 'PFNGLMATRIXPUSHEXTPROC',
'PFNGLMATRIXLOADTRANSPOSEFEXTPROC', 'PFNGLMATRIXLOADTRANSPOSEDEXTPROC',
'PFNGLMATRIXMULTTRANSPOSEFEXTPROC', 'PFNGLMATRIXMULTTRANSPOSEDEXTPROC',
'PFNGLTEXTUREPARAMETERFEXTPROC', 'PFNGLTEXTUREPARAMETERFVEXTPROC',
'PFNGLTEXTUREPARAMETERIEXTPROC', 'PFNGLTEXTUREPARAMETERIVEXTPROC',
'PFNGLTEXTUREIMAGE1DEXTPROC', 'PFNGLTEXTUREIMAGE2DEXTPROC',
'PFNGLTEXTURESUBIMAGE1DEXTPROC', 'PFNGLTEXTURESUBIMAGE2DEXTPROC',
'PFNGLCOPYTEXTUREIMAGE1DEXTPROC', 'PFNGLCOPYTEXTUREIMAGE2DEXTPROC',
'PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC', 'PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC',
'PFNGLGETTEXTUREIMAGEEXTPROC', 'PFNGLGETTEXTUREPARAMETERFVEXTPROC',
'PFNGLGETTEXTUREPARAMETERIVEXTPROC', 'PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC',
'PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC', 'PFNGLTEXTUREIMAGE3DEXTPROC',
'PFNGLTEXTURESUBIMAGE3DEXTPROC', 'PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC',
'PFNGLMULTITEXPARAMETERFEXTPROC', 'PFNGLMULTITEXPARAMETERFVEXTPROC',
'PFNGLMULTITEXPARAMETERIEXTPROC', 'PFNGLMULTITEXPARAMETERIVEXTPROC',
'PFNGLMULTITEXIMAGE1DEXTPROC', 'PFNGLMULTITEXIMAGE2DEXTPROC',
'PFNGLMULTITEXSUBIMAGE1DEXTPROC', 'PFNGLMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLCOPYMULTITEXIMAGE1DEXTPROC', 'PFNGLCOPYMULTITEXIMAGE2DEXTPROC',
'PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC', 'PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLGETMULTITEXIMAGEEXTPROC', 'PFNGLGETMULTITEXPARAMETERFVEXTPROC',
'PFNGLGETMULTITEXPARAMETERIVEXTPROC',
'PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC',
'PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC', 'PFNGLMULTITEXIMAGE3DEXTPROC',
'PFNGLMULTITEXSUBIMAGE3DEXTPROC', 'PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC',
'PFNGLBINDMULTITEXTUREEXTPROC', 'PFNGLENABLECLIENTSTATEINDEXEDEXTPROC',
'PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC', 'PFNGLMULTITEXCOORDPOINTEREXTPROC',
'PFNGLMULTITEXENVFEXTPROC', 'PFNGLMULTITEXENVFVEXTPROC',
'PFNGLMULTITEXENVIEXTPROC', 'PFNGLMULTITEXENVIVEXTPROC',
'PFNGLMULTITEXGENDEXTPROC', 'PFNGLMULTITEXGENDVEXTPROC',
'PFNGLMULTITEXGENFEXTPROC', 'PFNGLMULTITEXGENFVEXTPROC',
'PFNGLMULTITEXGENIEXTPROC', 'PFNGLMULTITEXGENIVEXTPROC',
'PFNGLGETMULTITEXENVFVEXTPROC', 'PFNGLGETMULTITEXENVIVEXTPROC',
'PFNGLGETMULTITEXGENDVEXTPROC', 'PFNGLGETMULTITEXGENFVEXTPROC',
'PFNGLGETMULTITEXGENIVEXTPROC', 'PFNGLGETFLOATINDEXEDVEXTPROC',
'PFNGLGETDOUBLEINDEXEDVEXTPROC', 'PFNGLGETPOINTERINDEXEDVEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC',
'PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC',
'PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC',
'PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC', 'PFNGLNAMEDPROGRAMSTRINGEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC',
'PFNGLGETNAMEDPROGRAMIVEXTPROC', 'PFNGLGETNAMEDPROGRAMSTRINGEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC',
'PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC',
'PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC',
'PFNGLTEXTUREPARAMETERIIVEXTPROC', 'PFNGLTEXTUREPARAMETERIUIVEXTPROC',
'PFNGLGETTEXTUREPARAMETERIIVEXTPROC', 'PFNGLGETTEXTUREPARAMETERIUIVEXTPROC',
'PFNGLMULTITEXPARAMETERIIVEXTPROC', 'PFNGLMULTITEXPARAMETERIUIVEXTPROC',
'PFNGLGETMULTITEXPARAMETERIIVEXTPROC', 'PFNGLGETMULTITEXPARAMETERIUIVEXTPROC',
'PFNGLPROGRAMUNIFORM1FEXTPROC', 'PFNGLPROGRAMUNIFORM2FEXTPROC',
'PFNGLPROGRAMUNIFORM3FEXTPROC', 'PFNGLPROGRAMUNIFORM4FEXTPROC',
'PFNGLPROGRAMUNIFORM1IEXTPROC', 'PFNGLPROGRAMUNIFORM2IEXTPROC',
'PFNGLPROGRAMUNIFORM3IEXTPROC', 'PFNGLPROGRAMUNIFORM4IEXTPROC',
'PFNGLPROGRAMUNIFORM1FVEXTPROC', 'PFNGLPROGRAMUNIFORM2FVEXTPROC',
'PFNGLPROGRAMUNIFORM3FVEXTPROC', 'PFNGLPROGRAMUNIFORM4FVEXTPROC',
'PFNGLPROGRAMUNIFORM1IVEXTPROC', 'PFNGLPROGRAMUNIFORM2IVEXTPROC',
'PFNGLPROGRAMUNIFORM3IVEXTPROC', 'PFNGLPROGRAMUNIFORM4IVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC', 'PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC', 'PFNGLPROGRAMUNIFORM1UIEXTPROC',
'PFNGLPROGRAMUNIFORM2UIEXTPROC', 'PFNGLPROGRAMUNIFORM3UIEXTPROC',
'PFNGLPROGRAMUNIFORM4UIEXTPROC', 'PFNGLPROGRAMUNIFORM1UIVEXTPROC',
'PFNGLPROGRAMUNIFORM2UIVEXTPROC', 'PFNGLPROGRAMUNIFORM3UIVEXTPROC',
'PFNGLPROGRAMUNIFORM4UIVEXTPROC', 'PFNGLNAMEDBUFFERDATAEXTPROC',
'PFNGLNAMEDBUFFERSUBDATAEXTPROC', 'PFNGLMAPNAMEDBUFFEREXTPROC',
'PFNGLUNMAPNAMEDBUFFEREXTPROC', 'PFNGLMAPNAMEDBUFFERRANGEEXTPROC',
'PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC',
'PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC', 'PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC',
'PFNGLGETNAMEDBUFFERPOINTERVEXTPROC', 'PFNGLGETNAMEDBUFFERSUBDATAEXTPROC',
'PFNGLTEXTUREBUFFEREXTPROC', 'PFNGLMULTITEXBUFFEREXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC',
'PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC',
'PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC',
'PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC',
'PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC',
'PFNGLGENERATETEXTUREMIPMAPEXTPROC', 'PFNGLGENERATEMULTITEXMIPMAPEXTPROC',
'PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC', 'PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC',
'PFNGLFRAMEBUFFERREADBUFFEREXTPROC', 'PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC',
'PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC',
'PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC', 'PFNGLTEXTURERENDERBUFFEREXTPROC',
'PFNGLMULTITEXRENDERBUFFEREXTPROC', 'PFNGLPROGRAMUNIFORM1DEXTPROC',
'PFNGLPROGRAMUNIFORM2DEXTPROC', 'PFNGLPROGRAMUNIFORM3DEXTPROC',
'PFNGLPROGRAMUNIFORM4DEXTPROC', 'PFNGLPROGRAMUNIFORM1DVEXTPROC',
'PFNGLPROGRAMUNIFORM2DVEXTPROC', 'PFNGLPROGRAMUNIFORM3DVEXTPROC',
'PFNGLPROGRAMUNIFORM4DVEXTPROC', 'PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC', 'PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC',
'PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC', 'GL_EXT_vertex_array_bgra',
'GL_EXT_texture_swizzle', 'GL_NV_explicit_multisample',
'glGetMultisamplefvNV', 'glSampleMaskIndexedNV', 'glTexRenderbufferNV',
'PFNGLGETMULTISAMPLEFVNVPROC', 'PFNGLSAMPLEMASKINDEXEDNVPROC',
'PFNGLTEXRENDERBUFFERNVPROC', 'GL_NV_transform_feedback2',
'glBindTransformFeedbackNV', 'glDeleteTransformFeedbacksNV',
'glGenTransformFeedbacksNV', 'glIsTransformFeedbackNV',
'glPauseTransformFeedbackNV', 'glResumeTransformFeedbackNV',
'glDrawTransformFeedbackNV', 'PFNGLBINDTRANSFORMFEEDBACKNVPROC',
'PFNGLDELETETRANSFORMFEEDBACKSNVPROC', 'PFNGLGENTRANSFORMFEEDBACKSNVPROC',
'PFNGLISTRANSFORMFEEDBACKNVPROC', 'PFNGLPAUSETRANSFORMFEEDBACKNVPROC',
'PFNGLRESUMETRANSFORMFEEDBACKNVPROC', 'PFNGLDRAWTRANSFORMFEEDBACKNVPROC',
'GL_ATI_meminfo', 'GL_AMD_performance_monitor', 'glGetPerfMonitorGroupsAMD',
'glGetPerfMonitorCountersAMD', 'glGetPerfMonitorGroupStringAMD',
'glGetPerfMonitorCounterStringAMD', 'glGetPerfMonitorCounterInfoAMD',
'glGenPerfMonitorsAMD', 'glDeletePerfMonitorsAMD',
'glSelectPerfMonitorCountersAMD', 'glBeginPerfMonitorAMD',
'glEndPerfMonitorAMD', 'glGetPerfMonitorCounterDataAMD',
'PFNGLGETPERFMONITORGROUPSAMDPROC', 'PFNGLGETPERFMONITORCOUNTERSAMDPROC',
'PFNGLGETPERFMONITORGROUPSTRINGAMDPROC',
'PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC',
'PFNGLGETPERFMONITORCOUNTERINFOAMDPROC', 'PFNGLGENPERFMONITORSAMDPROC',
'PFNGLDELETEPERFMONITORSAMDPROC', 'PFNGLSELECTPERFMONITORCOUNTERSAMDPROC',
'PFNGLBEGINPERFMONITORAMDPROC', 'PFNGLENDPERFMONITORAMDPROC',
'PFNGLGETPERFMONITORCOUNTERDATAAMDPROC', 'GL_AMD_texture_texture4',
'GL_AMD_vertex_shader_tesselator', 'glTessellationFactorAMD',
'glTessellationModeAMD', 'PFNGLTESSELLATIONFACTORAMDPROC',
'PFNGLTESSELLATIONMODEAMDPROC', 'GL_EXT_provoking_vertex',
'glProvokingVertexEXT', 'PFNGLPROVOKINGVERTEXEXTPROC', 'GL_EXT_texture_snorm',
'GL_AMD_draw_buffers_blend', 'glBlendFuncIndexedAMD',
'glBlendFuncSeparateIndexedAMD', 'glBlendEquationIndexedAMD',
'glBlendEquationSeparateIndexedAMD', 'PFNGLBLENDFUNCINDEXEDAMDPROC',
'PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC', 'PFNGLBLENDEQUATIONINDEXEDAMDPROC',
'PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC', 'GL_APPLE_texture_range',
'glTextureRangeAPPLE', 'glGetTexParameterPointervAPPLE',
'PFNGLTEXTURERANGEAPPLEPROC', 'PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC',
'GL_APPLE_float_pixels', 'GL_APPLE_vertex_program_evaluators',
'glEnableVertexAttribAPPLE', 'glDisableVertexAttribAPPLE',
'glIsVertexAttribEnabledAPPLE', 'glMapVertexAttrib1dAPPLE',
'glMapVertexAttrib1fAPPLE', 'glMapVertexAttrib2dAPPLE',
'glMapVertexAttrib2fAPPLE', 'PFNGLENABLEVERTEXATTRIBAPPLEPROC',
'PFNGLDISABLEVERTEXATTRIBAPPLEPROC', 'PFNGLISVERTEXATTRIBENABLEDAPPLEPROC',
'PFNGLMAPVERTEXATTRIB1DAPPLEPROC', 'PFNGLMAPVERTEXATTRIB1FAPPLEPROC',
'PFNGLMAPVERTEXATTRIB2DAPPLEPROC', 'PFNGLMAPVERTEXATTRIB2FAPPLEPROC',
'GL_APPLE_aux_depth_stencil', 'GL_APPLE_object_purgeable',
'glObjectPurgeableAPPLE', 'glObjectUnpurgeableAPPLE',
'glGetObjectParameterivAPPLE', 'PFNGLOBJECTPURGEABLEAPPLEPROC',
'PFNGLOBJECTUNPURGEABLEAPPLEPROC', 'PFNGLGETOBJECTPARAMETERIVAPPLEPROC',
'GL_APPLE_row_bytes', 'GL_APPLE_rgb_422', 'GL_NV_video_capture',
'glBeginVideoCaptureNV', 'glBindVideoCaptureStreamBufferNV',
'glBindVideoCaptureStreamTextureNV', 'glEndVideoCaptureNV',
'glGetVideoCaptureivNV', 'glGetVideoCaptureStreamivNV',
'glGetVideoCaptureStreamfvNV', 'glGetVideoCaptureStreamdvNV',
'glVideoCaptureNV', 'glVideoCaptureStreamParameterivNV',
'glVideoCaptureStreamParameterfvNV', 'glVideoCaptureStreamParameterdvNV',
'PFNGLBEGINVIDEOCAPTURENVPROC', 'PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC',
'PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC', 'PFNGLENDVIDEOCAPTURENVPROC',
'PFNGLGETVIDEOCAPTUREIVNVPROC', 'PFNGLGETVIDEOCAPTURESTREAMIVNVPROC',
'PFNGLGETVIDEOCAPTURESTREAMFVNVPROC', 'PFNGLGETVIDEOCAPTURESTREAMDVNVPROC',
'PFNGLVIDEOCAPTURENVPROC', 'PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC',
'PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC',
'PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC', 'GL_NV_copy_image',
'glCopyImageSubDataNV', 'PFNGLCOPYIMAGESUBDATANVPROC',
'GL_EXT_separate_shader_objects', 'glUseShaderProgramEXT',
'glActiveProgramEXT', 'glCreateShaderProgramEXT',
'PFNGLUSESHADERPROGRAMEXTPROC', 'PFNGLACTIVEPROGRAMEXTPROC',
'PFNGLCREATESHADERPROGRAMEXTPROC', 'GL_NV_parameter_buffer_object2',
'GL_NV_shader_buffer_load', 'glMakeBufferResidentNV',
'glMakeBufferNonResidentNV', 'glIsBufferResidentNV',
'glMakeNamedBufferResidentNV', 'glMakeNamedBufferNonResidentNV',
'glIsNamedBufferResidentNV', 'glGetBufferParameterui64vNV',
'glGetNamedBufferParameterui64vNV', 'glGetIntegerui64vNV', 'glUniformui64NV',
'glUniformui64vNV', 'glGetUniformui64vNV', 'glProgramUniformui64NV',
'glProgramUniformui64vNV', 'PFNGLMAKEBUFFERRESIDENTNVPROC',
'PFNGLMAKEBUFFERNONRESIDENTNVPROC', 'PFNGLISBUFFERRESIDENTNVPROC',
'PFNGLMAKENAMEDBUFFERRESIDENTNVPROC', 'PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC',
'PFNGLISNAMEDBUFFERRESIDENTNVPROC', 'PFNGLGETBUFFERPARAMETERUI64VNVPROC',
'PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC', 'PFNGLGETINTEGERUI64VNVPROC',
'PFNGLUNIFORMUI64NVPROC', 'PFNGLUNIFORMUI64VNVPROC',
'PFNGLGETUNIFORMUI64VNVPROC', 'PFNGLPROGRAMUNIFORMUI64NVPROC',
'PFNGLPROGRAMUNIFORMUI64VNVPROC', 'GL_NV_vertex_buffer_unified_memory',
'glBufferAddressRangeNV', 'glVertexFormatNV', 'glNormalFormatNV',
'glColorFormatNV', 'glIndexFormatNV', 'glTexCoordFormatNV',
'glEdgeFlagFormatNV', 'glSecondaryColorFormatNV', 'glFogCoordFormatNV',
'glVertexAttribFormatNV', 'glVertexAttribIFormatNV', 'glGetIntegerui64i_vNV',
'PFNGLBUFFERADDRESSRANGENVPROC', 'PFNGLVERTEXFORMATNVPROC',
'PFNGLNORMALFORMATNVPROC', 'PFNGLCOLORFORMATNVPROC', 'PFNGLINDEXFORMATNVPROC',
'PFNGLTEXCOORDFORMATNVPROC', 'PFNGLEDGEFLAGFORMATNVPROC',
'PFNGLSECONDARYCOLORFORMATNVPROC', 'PFNGLFOGCOORDFORMATNVPROC',
'PFNGLVERTEXATTRIBFORMATNVPROC', 'PFNGLVERTEXATTRIBIFORMATNVPROC',
'PFNGLGETINTEGERUI64I_VNVPROC', 'GL_NV_texture_barrier', 'glTextureBarrierNV',
'PFNGLTEXTUREBARRIERNVPROC', 'GL_AMD_shader_stencil_export',
'GL_AMD_seamless_cubemap_per_texture', 'GL_AMD_conservative_depth',
'GL_EXT_shader_image_load_store', 'glBindImageTextureEXT',
'glMemoryBarrierEXT', 'PFNGLBINDIMAGETEXTUREEXTPROC',
'PFNGLMEMORYBARRIEREXTPROC', 'GL_EXT_vertex_attrib_64bit',
'glVertexAttribL1dEXT', 'glVertexAttribL2dEXT', 'glVertexAttribL3dEXT',
'glVertexAttribL4dEXT', 'glVertexAttribL1dvEXT', 'glVertexAttribL2dvEXT',
'glVertexAttribL3dvEXT', 'glVertexAttribL4dvEXT', 'glVertexAttribLPointerEXT',
'glGetVertexAttribLdvEXT', 'glVertexArrayVertexAttribLOffsetEXT',
'PFNGLVERTEXATTRIBL1DEXTPROC', 'PFNGLVERTEXATTRIBL2DEXTPROC',
'PFNGLVERTEXATTRIBL3DEXTPROC', 'PFNGLVERTEXATTRIBL4DEXTPROC',
'PFNGLVERTEXATTRIBL1DVEXTPROC', 'PFNGLVERTEXATTRIBL2DVEXTPROC',
'PFNGLVERTEXATTRIBL3DVEXTPROC', 'PFNGLVERTEXATTRIBL4DVEXTPROC',
'PFNGLVERTEXATTRIBLPOINTEREXTPROC', 'PFNGLGETVERTEXATTRIBLDVEXTPROC',
'PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC', 'GL_NV_gpu_program5',
'glProgramSubroutineParametersuivNV', 'glGetProgramSubroutineParameteruivNV',
'PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC',
'PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC', 'GL_NV_gpu_shader5',
'glUniform1i64NV', 'glUniform2i64NV', 'glUniform3i64NV', 'glUniform4i64NV',
'glUniform1i64vNV', 'glUniform2i64vNV', 'glUniform3i64vNV',
'glUniform4i64vNV', 'glUniform1ui64NV', 'glUniform2ui64NV',
'glUniform3ui64NV', 'glUniform4ui64NV', 'glUniform1ui64vNV',
'glUniform2ui64vNV', 'glUniform3ui64vNV', 'glUniform4ui64vNV',
'glGetUniformi64vNV', 'glProgramUniform1i64NV', 'glProgramUniform2i64NV',
'glProgramUniform3i64NV', 'glProgramUniform4i64NV', 'glProgramUniform1i64vNV',
'glProgramUniform2i64vNV', 'glProgramUniform3i64vNV',
'glProgramUniform4i64vNV', 'glProgramUniform1ui64NV',
'glProgramUniform2ui64NV', 'glProgramUniform3ui64NV',
'glProgramUniform4ui64NV', 'glProgramUniform1ui64vNV',
'glProgramUniform2ui64vNV', 'glProgramUniform3ui64vNV',
'glProgramUniform4ui64vNV', 'PFNGLUNIFORM1I64NVPROC',
'PFNGLUNIFORM2I64NVPROC', 'PFNGLUNIFORM3I64NVPROC', 'PFNGLUNIFORM4I64NVPROC',
'PFNGLUNIFORM1I64VNVPROC', 'PFNGLUNIFORM2I64VNVPROC',
'PFNGLUNIFORM3I64VNVPROC', 'PFNGLUNIFORM4I64VNVPROC',
'PFNGLUNIFORM1UI64NVPROC', 'PFNGLUNIFORM2UI64NVPROC',
'PFNGLUNIFORM3UI64NVPROC', 'PFNGLUNIFORM4UI64NVPROC',
'PFNGLUNIFORM1UI64VNVPROC', 'PFNGLUNIFORM2UI64VNVPROC',
'PFNGLUNIFORM3UI64VNVPROC', 'PFNGLUNIFORM4UI64VNVPROC',
'PFNGLGETUNIFORMI64VNVPROC', 'PFNGLPROGRAMUNIFORM1I64NVPROC',
'PFNGLPROGRAMUNIFORM2I64NVPROC', 'PFNGLPROGRAMUNIFORM3I64NVPROC',
'PFNGLPROGRAMUNIFORM4I64NVPROC', 'PFNGLPROGRAMUNIFORM1I64VNVPROC',
'PFNGLPROGRAMUNIFORM2I64VNVPROC', 'PFNGLPROGRAMUNIFORM3I64VNVPROC',
'PFNGLPROGRAMUNIFORM4I64VNVPROC', 'PFNGLPROGRAMUNIFORM1UI64NVPROC',
'PFNGLPROGRAMUNIFORM2UI64NVPROC', 'PFNGLPROGRAMUNIFORM3UI64NVPROC',
'PFNGLPROGRAMUNIFORM4UI64NVPROC', 'PFNGLPROGRAMUNIFORM1UI64VNVPROC',
'PFNGLPROGRAMUNIFORM2UI64VNVPROC', 'PFNGLPROGRAMUNIFORM3UI64VNVPROC',
'PFNGLPROGRAMUNIFORM4UI64VNVPROC', 'GL_NV_shader_buffer_store',
'GL_NV_tessellation_program5', 'GL_NV_vertex_attrib_integer_64bit',
'glVertexAttribL1i64NV', 'glVertexAttribL2i64NV', 'glVertexAttribL3i64NV',
'glVertexAttribL4i64NV', 'glVertexAttribL1i64vNV', 'glVertexAttribL2i64vNV',
'glVertexAttribL3i64vNV', 'glVertexAttribL4i64vNV', 'glVertexAttribL1ui64NV',
'glVertexAttribL2ui64NV', 'glVertexAttribL3ui64NV', 'glVertexAttribL4ui64NV',
'glVertexAttribL1ui64vNV', 'glVertexAttribL2ui64vNV',
'glVertexAttribL3ui64vNV', 'glVertexAttribL4ui64vNV',
'glGetVertexAttribLi64vNV', 'glGetVertexAttribLui64vNV',
'glVertexAttribLFormatNV', 'PFNGLVERTEXATTRIBL1I64NVPROC',
'PFNGLVERTEXATTRIBL2I64NVPROC', 'PFNGLVERTEXATTRIBL3I64NVPROC',
'PFNGLVERTEXATTRIBL4I64NVPROC', 'PFNGLVERTEXATTRIBL1I64VNVPROC',
'PFNGLVERTEXATTRIBL2I64VNVPROC', 'PFNGLVERTEXATTRIBL3I64VNVPROC',
'PFNGLVERTEXATTRIBL4I64VNVPROC', 'PFNGLVERTEXATTRIBL1UI64NVPROC',
'PFNGLVERTEXATTRIBL2UI64NVPROC', 'PFNGLVERTEXATTRIBL3UI64NVPROC',
'PFNGLVERTEXATTRIBL4UI64NVPROC', 'PFNGLVERTEXATTRIBL1UI64VNVPROC',
'PFNGLVERTEXATTRIBL2UI64VNVPROC', 'PFNGLVERTEXATTRIBL3UI64VNVPROC',
'PFNGLVERTEXATTRIBL4UI64VNVPROC', 'PFNGLGETVERTEXATTRIBLI64VNVPROC',
'PFNGLGETVERTEXATTRIBLUI64VNVPROC', 'PFNGLVERTEXATTRIBLFORMATNVPROC',
'GL_NV_multisample_coverage', 'GL_AMD_name_gen_delete', 'glGenNamesAMD',
'glDeleteNamesAMD', 'glIsNameAMD', 'PFNGLGENNAMESAMDPROC',
'PFNGLDELETENAMESAMDPROC', 'PFNGLISNAMEAMDPROC', 'GL_AMD_debug_output',
'glDebugMessageEnableAMD', 'glDebugMessageInsertAMD',
'glDebugMessageCallbackAMD', 'glGetDebugMessageLogAMD',
'PFNGLDEBUGMESSAGEENABLEAMDPROC', 'PFNGLDEBUGMESSAGEINSERTAMDPROC',
'PFNGLDEBUGMESSAGECALLBACKAMDPROC', 'PFNGLGETDEBUGMESSAGELOGAMDPROC',
'GL_NV_vdpau_interop', 'glVDPAUInitNV', 'glVDPAUFiniNV',
'glVDPAURegisterVideoSurfaceNV', 'glVDPAURegisterOutputSurfaceNV',
'glVDPAUIsSurfaceNV', 'glVDPAUUnregisterSurfaceNV', 'glVDPAUGetSurfaceivNV',
'glVDPAUSurfaceAccessNV', 'glVDPAUMapSurfacesNV', 'glVDPAUUnmapSurfacesNV',
'PFNGLVDPAUINITNVPROC', 'PFNGLVDPAUFININVPROC',
'PFNGLVDPAUREGISTERVIDEOSURFACENVPROC',
'PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC', 'PFNGLVDPAUISSURFACENVPROC',
'PFNGLVDPAUUNREGISTERSURFACENVPROC', 'PFNGLVDPAUGETSURFACEIVNVPROC',
'PFNGLVDPAUSURFACEACCESSNVPROC', 'PFNGLVDPAUMAPSURFACESNVPROC',
'PFNGLVDPAUUNMAPSURFACESNVPROC', 'GL_AMD_transform_feedback3_lines_triangles',
'GL_AMD_depth_clamp_separate', 'GL_EXT_texture_sRGB_decode',
'GL_NV_texture_multisample', 'glTexImage2DMultisampleCoverageNV',
'glTexImage3DMultisampleCoverageNV', 'glTextureImage2DMultisampleNV',
'glTextureImage3DMultisampleNV', 'glTextureImage2DMultisampleCoverageNV',
'glTextureImage3DMultisampleCoverageNV',
'PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC',
'PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC',
'PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC',
'PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC',
'PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC',
'PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC', 'GL_AMD_blend_minmax_factor',
'GL_AMD_sample_positions', 'glSetMultisamplefvAMD',
'PFNGLSETMULTISAMPLEFVAMDPROC', 'GL_EXT_x11_sync_object', 'glImportSyncEXT',
'PFNGLIMPORTSYNCEXTPROC', 'GL_AMD_multi_draw_indirect',
'glMultiDrawArraysIndirectAMD', 'glMultiDrawElementsIndirectAMD',
'PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC',
'PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC',
'GL_EXT_framebuffer_multisample_blit_scaled', 'GL_NV_path_rendering',
'glGenPathsNV', 'glDeletePathsNV', 'glIsPathNV', 'glPathCommandsNV',
'glPathCoordsNV', 'glPathSubCommandsNV', 'glPathSubCoordsNV',
'glPathStringNV', 'glPathGlyphsNV', 'glPathGlyphRangeNV', 'glWeightPathsNV',
'glCopyPathNV', 'glInterpolatePathsNV', 'glTransformPathNV',
'glPathParameterivNV', 'glPathParameteriNV', 'glPathParameterfvNV',
'glPathParameterfNV', 'glPathDashArrayNV', 'glPathStencilFuncNV',
'glPathStencilDepthOffsetNV', 'glStencilFillPathNV', 'glStencilStrokePathNV',
'glStencilFillPathInstancedNV', 'glStencilStrokePathInstancedNV',
'glPathCoverDepthFuncNV', 'glPathColorGenNV', 'glPathTexGenNV',
'glPathFogGenNV', 'glCoverFillPathNV', 'glCoverStrokePathNV',
'glCoverFillPathInstancedNV', 'glCoverStrokePathInstancedNV',
'glGetPathParameterivNV', 'glGetPathParameterfvNV', 'glGetPathCommandsNV',
'glGetPathCoordsNV', 'glGetPathDashArrayNV', 'glGetPathMetricsNV',
'glGetPathMetricRangeNV', 'glGetPathSpacingNV', 'glGetPathColorGenivNV',
'glGetPathColorGenfvNV', 'glGetPathTexGenivNV', 'glGetPathTexGenfvNV',
'glIsPointInFillPathNV', 'glIsPointInStrokePathNV', 'glGetPathLengthNV',
'glPointAlongPathNV', 'PFNGLGENPATHSNVPROC', 'PFNGLDELETEPATHSNVPROC',
'PFNGLISPATHNVPROC', 'PFNGLPATHCOMMANDSNVPROC', 'PFNGLPATHCOORDSNVPROC',
'PFNGLPATHSUBCOMMANDSNVPROC', 'PFNGLPATHSUBCOORDSNVPROC',
'PFNGLPATHSTRINGNVPROC', 'PFNGLPATHGLYPHSNVPROC', 'PFNGLPATHGLYPHRANGENVPROC',
'PFNGLWEIGHTPATHSNVPROC', 'PFNGLCOPYPATHNVPROC',
'PFNGLINTERPOLATEPATHSNVPROC', 'PFNGLTRANSFORMPATHNVPROC',
'PFNGLPATHPARAMETERIVNVPROC', 'PFNGLPATHPARAMETERINVPROC',
'PFNGLPATHPARAMETERFVNVPROC', 'PFNGLPATHPARAMETERFNVPROC',
'PFNGLPATHDASHARRAYNVPROC', 'PFNGLPATHSTENCILFUNCNVPROC',
'PFNGLPATHSTENCILDEPTHOFFSETNVPROC', 'PFNGLSTENCILFILLPATHNVPROC',
'PFNGLSTENCILSTROKEPATHNVPROC', 'PFNGLSTENCILFILLPATHINSTANCEDNVPROC',
'PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC', 'PFNGLPATHCOVERDEPTHFUNCNVPROC',
'PFNGLPATHCOLORGENNVPROC', 'PFNGLPATHTEXGENNVPROC', 'PFNGLPATHFOGGENNVPROC',
'PFNGLCOVERFILLPATHNVPROC', 'PFNGLCOVERSTROKEPATHNVPROC',
'PFNGLCOVERFILLPATHINSTANCEDNVPROC', 'PFNGLCOVERSTROKEPATHINSTANCEDNVPROC',
'PFNGLGETPATHPARAMETERIVNVPROC', 'PFNGLGETPATHPARAMETERFVNVPROC',
'PFNGLGETPATHCOMMANDSNVPROC', 'PFNGLGETPATHCOORDSNVPROC',
'PFNGLGETPATHDASHARRAYNVPROC', 'PFNGLGETPATHMETRICSNVPROC',
'PFNGLGETPATHMETRICRANGENVPROC', 'PFNGLGETPATHSPACINGNVPROC',
'PFNGLGETPATHCOLORGENIVNVPROC', 'PFNGLGETPATHCOLORGENFVNVPROC',
'PFNGLGETPATHTEXGENIVNVPROC', 'PFNGLGETPATHTEXGENFVNVPROC',
'PFNGLISPOINTINFILLPATHNVPROC', 'PFNGLISPOINTINSTROKEPATHNVPROC',
'PFNGLGETPATHLENGTHNVPROC', 'PFNGLPOINTALONGPATHNVPROC',
'GL_AMD_pinned_memory', 'GL_AMD_stencil_operation_extended',
'glStencilOpValueAMD', 'PFNGLSTENCILOPVALUEAMDPROC',
'GL_AMD_vertex_shader_viewport_index', 'GL_AMD_vertex_shader_layer',
'GL_NV_bindless_texture', 'glGetTextureHandleNV',
'glGetTextureSamplerHandleNV', 'glMakeTextureHandleResidentNV',
'glMakeTextureHandleNonResidentNV', 'glGetImageHandleNV',
'glMakeImageHandleResidentNV', 'glMakeImageHandleNonResidentNV',
'glUniformHandleui64NV', 'glUniformHandleui64vNV',
'glProgramUniformHandleui64NV', 'glProgramUniformHandleui64vNV',
'glIsTextureHandleResidentNV', 'glIsImageHandleResidentNV',
'PFNGLGETTEXTUREHANDLENVPROC', 'PFNGLGETTEXTURESAMPLERHANDLENVPROC',
'PFNGLMAKETEXTUREHANDLERESIDENTNVPROC',
'PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC', 'PFNGLGETIMAGEHANDLENVPROC',
'PFNGLMAKEIMAGEHANDLERESIDENTNVPROC', 'PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC',
'PFNGLUNIFORMHANDLEUI64NVPROC', 'PFNGLUNIFORMHANDLEUI64VNVPROC',
'PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC', 'PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC',
'PFNGLISTEXTUREHANDLERESIDENTNVPROC', 'PFNGLISIMAGEHANDLERESIDENTNVPROC',
'GL_NV_shader_atomic_float', 'GL_AMD_query_buffer_object']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for /System/Library/Frameworks/AGL.framework/Headers/agl.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: gengl.py 601 2007-02-04 05:36:59Z Alex.Holkner $'
from ctypes import *
from pyglet.gl.lib import link_AGL as _link_function
if not _link_function:
raise ImportError('AGL framework is not available.')
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for /System/Library/Frameworks/AGL.framework/Headers/agl.h
AGL_VERSION_2_0 = 1 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:41
class struct_GDevice(Structure):
__slots__ = [
]
struct_GDevice._fields_ = [
('_opaque_struct', c_int)
]
GDevice = struct_GDevice # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/QD.framework/Headers/Quickdraw.h:1347
GDPtr = POINTER(GDevice) # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/QD.framework/Headers/Quickdraw.h:1348
GDHandle = POINTER(GDPtr) # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/QD.framework/Headers/Quickdraw.h:1349
AGLDevice = GDHandle # /System/Library/Frameworks/AGL.framework/Headers/agl.h:46
class struct_OpaqueGrafPtr(Structure):
__slots__ = [
]
struct_OpaqueGrafPtr._fields_ = [
('_opaque_struct', c_int)
]
GrafPtr = POINTER(struct_OpaqueGrafPtr) # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/QD.framework/Headers/Quickdraw.h:1009
CGrafPtr = GrafPtr # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/QD.framework/Headers/Quickdraw.h:1392
AGLDrawable = CGrafPtr # /System/Library/Frameworks/AGL.framework/Headers/agl.h:51
class struct___AGLRendererInfoRec(Structure):
__slots__ = [
]
struct___AGLRendererInfoRec._fields_ = [
('_opaque_struct', c_int)
]
AGLRendererInfo = POINTER(struct___AGLRendererInfoRec) # /System/Library/Frameworks/AGL.framework/Headers/agl.h:56
class struct___AGLPixelFormatRec(Structure):
__slots__ = [
]
struct___AGLPixelFormatRec._fields_ = [
('_opaque_struct', c_int)
]
AGLPixelFormat = POINTER(struct___AGLPixelFormatRec) # /System/Library/Frameworks/AGL.framework/Headers/agl.h:57
class struct___AGLContextRec(Structure):
__slots__ = [
]
struct___AGLContextRec._fields_ = [
('_opaque_struct', c_int)
]
AGLContext = POINTER(struct___AGLContextRec) # /System/Library/Frameworks/AGL.framework/Headers/agl.h:58
class struct___AGLPBufferRec(Structure):
__slots__ = [
]
struct___AGLPBufferRec._fields_ = [
('_opaque_struct', c_int)
]
AGLPbuffer = POINTER(struct___AGLPBufferRec) # /System/Library/Frameworks/AGL.framework/Headers/agl.h:59
AGL_NONE = 0 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:66
AGL_ALL_RENDERERS = 1 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:67
AGL_BUFFER_SIZE = 2 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:68
AGL_LEVEL = 3 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:69
AGL_RGBA = 4 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:70
AGL_DOUBLEBUFFER = 5 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:71
AGL_STEREO = 6 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:72
AGL_AUX_BUFFERS = 7 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:73
AGL_RED_SIZE = 8 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:74
AGL_GREEN_SIZE = 9 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:75
AGL_BLUE_SIZE = 10 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:76
AGL_ALPHA_SIZE = 11 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:77
AGL_DEPTH_SIZE = 12 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:78
AGL_STENCIL_SIZE = 13 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:79
AGL_ACCUM_RED_SIZE = 14 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:80
AGL_ACCUM_GREEN_SIZE = 15 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:81
AGL_ACCUM_BLUE_SIZE = 16 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:82
AGL_ACCUM_ALPHA_SIZE = 17 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:83
AGL_PIXEL_SIZE = 50 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:88
AGL_MINIMUM_POLICY = 51 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:89
AGL_MAXIMUM_POLICY = 52 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:90
AGL_OFFSCREEN = 53 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:91
AGL_FULLSCREEN = 54 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:92
AGL_SAMPLE_BUFFERS_ARB = 55 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:93
AGL_SAMPLES_ARB = 56 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:94
AGL_AUX_DEPTH_STENCIL = 57 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:95
AGL_COLOR_FLOAT = 58 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:96
AGL_MULTISAMPLE = 59 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:97
AGL_SUPERSAMPLE = 60 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:98
AGL_SAMPLE_ALPHA = 61 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:99
AGL_RENDERER_ID = 70 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:104
AGL_SINGLE_RENDERER = 71 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:105
AGL_NO_RECOVERY = 72 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:106
AGL_ACCELERATED = 73 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:107
AGL_CLOSEST_POLICY = 74 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:108
AGL_ROBUST = 75 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:109
AGL_BACKING_STORE = 76 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:110
AGL_MP_SAFE = 78 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:111
AGL_WINDOW = 80 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:113
AGL_MULTISCREEN = 81 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:114
AGL_VIRTUAL_SCREEN = 82 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:115
AGL_COMPLIANT = 83 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:116
AGL_PBUFFER = 90 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:118
AGL_BUFFER_MODES = 100 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:135
AGL_MIN_LEVEL = 101 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:136
AGL_MAX_LEVEL = 102 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:137
AGL_COLOR_MODES = 103 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:138
AGL_ACCUM_MODES = 104 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:139
AGL_DEPTH_MODES = 105 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:140
AGL_STENCIL_MODES = 106 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:141
AGL_MAX_AUX_BUFFERS = 107 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:142
AGL_VIDEO_MEMORY = 120 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:143
AGL_TEXTURE_MEMORY = 121 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:144
AGL_RENDERER_COUNT = 128 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:145
AGL_SWAP_RECT = 200 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:150
AGL_BUFFER_RECT = 202 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:151
AGL_SWAP_LIMIT = 203 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:152
AGL_COLORMAP_TRACKING = 210 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:153
AGL_COLORMAP_ENTRY = 212 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:154
AGL_RASTERIZATION = 220 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:155
AGL_SWAP_INTERVAL = 222 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:156
AGL_STATE_VALIDATION = 230 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:157
AGL_BUFFER_NAME = 231 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:158
AGL_ORDER_CONTEXT_TO_FRONT = 232 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:159
AGL_CONTEXT_SURFACE_ID = 233 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:160
AGL_CONTEXT_DISPLAY_ID = 234 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:161
AGL_SURFACE_ORDER = 235 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:162
AGL_SURFACE_OPACITY = 236 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:163
AGL_CLIP_REGION = 254 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:164
AGL_FS_CAPTURE_SINGLE = 255 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:165
AGL_SURFACE_BACKING_SIZE = 304 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:166
AGL_ENABLE_SURFACE_BACKING_SIZE = 305 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:167
AGL_SURFACE_VOLATILE = 306 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:168
AGL_FORMAT_CACHE_SIZE = 501 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:172
AGL_CLEAR_FORMAT_CACHE = 502 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:173
AGL_RETAIN_RENDERERS = 503 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:174
AGL_MONOSCOPIC_BIT = 1 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:177
AGL_STEREOSCOPIC_BIT = 2 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:178
AGL_SINGLEBUFFER_BIT = 4 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:179
AGL_DOUBLEBUFFER_BIT = 8 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:180
AGL_0_BIT = 1 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:183
AGL_1_BIT = 2 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:184
AGL_2_BIT = 4 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:185
AGL_3_BIT = 8 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:186
AGL_4_BIT = 16 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:187
AGL_5_BIT = 32 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:188
AGL_6_BIT = 64 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:189
AGL_8_BIT = 128 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:190
AGL_10_BIT = 256 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:191
AGL_12_BIT = 512 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:192
AGL_16_BIT = 1024 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:193
AGL_24_BIT = 2048 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:194
AGL_32_BIT = 4096 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:195
AGL_48_BIT = 8192 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:196
AGL_64_BIT = 16384 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:197
AGL_96_BIT = 32768 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:198
AGL_128_BIT = 65536 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:199
AGL_RGB8_BIT = 1 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:202
AGL_RGB8_A8_BIT = 2 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:203
AGL_BGR233_BIT = 4 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:204
AGL_BGR233_A8_BIT = 8 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:205
AGL_RGB332_BIT = 16 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:206
AGL_RGB332_A8_BIT = 32 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:207
AGL_RGB444_BIT = 64 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:208
AGL_ARGB4444_BIT = 128 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:209
AGL_RGB444_A8_BIT = 256 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:210
AGL_RGB555_BIT = 512 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:211
AGL_ARGB1555_BIT = 1024 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:212
AGL_RGB555_A8_BIT = 2048 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:213
AGL_RGB565_BIT = 4096 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:214
AGL_RGB565_A8_BIT = 8192 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:215
AGL_RGB888_BIT = 16384 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:216
AGL_ARGB8888_BIT = 32768 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:217
AGL_RGB888_A8_BIT = 65536 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:218
AGL_RGB101010_BIT = 131072 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:219
AGL_ARGB2101010_BIT = 262144 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:220
AGL_RGB101010_A8_BIT = 524288 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:221
AGL_RGB121212_BIT = 1048576 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:222
AGL_ARGB12121212_BIT = 2097152 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:223
AGL_RGB161616_BIT = 4194304 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:224
AGL_ARGB16161616_BIT = 8388608 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:225
AGL_INDEX8_BIT = 536870912 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:226
AGL_INDEX16_BIT = 1073741824 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:227
AGL_RGBFLOAT64_BIT = 16777216 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:228
AGL_RGBAFLOAT64_BIT = 33554432 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:229
AGL_RGBFLOAT128_BIT = 67108864 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:230
AGL_RGBAFLOAT128_BIT = 134217728 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:231
AGL_RGBFLOAT256_BIT = 268435456 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:232
AGL_RGBAFLOAT256_BIT = 536870912 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:233
AGL_NO_ERROR = 0 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:238
AGL_BAD_ATTRIBUTE = 10000 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:240
AGL_BAD_PROPERTY = 10001 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:241
AGL_BAD_PIXELFMT = 10002 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:242
AGL_BAD_RENDINFO = 10003 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:243
AGL_BAD_CONTEXT = 10004 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:244
AGL_BAD_DRAWABLE = 10005 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:245
AGL_BAD_GDEV = 10006 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:246
AGL_BAD_STATE = 10007 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:247
AGL_BAD_VALUE = 10008 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:248
AGL_BAD_MATCH = 10009 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:249
AGL_BAD_ENUM = 10010 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:250
AGL_BAD_OFFSCREEN = 10011 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:251
AGL_BAD_FULLSCREEN = 10012 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:252
AGL_BAD_WINDOW = 10013 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:253
AGL_BAD_POINTER = 10014 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:254
AGL_BAD_MODULE = 10015 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:255
AGL_BAD_ALLOC = 10016 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:256
AGL_BAD_CONNECTION = 10017 # /System/Library/Frameworks/AGL.framework/Headers/agl.h:257
GLint = c_long # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:47
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:264
aglChoosePixelFormat = _link_function('aglChoosePixelFormat', AGLPixelFormat, [POINTER(AGLDevice), GLint, POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:265
aglDestroyPixelFormat = _link_function('aglDestroyPixelFormat', None, [AGLPixelFormat], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:266
aglNextPixelFormat = _link_function('aglNextPixelFormat', AGLPixelFormat, [AGLPixelFormat], None)
GLboolean = c_ubyte # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:43
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:267
aglDescribePixelFormat = _link_function('aglDescribePixelFormat', GLboolean, [AGLPixelFormat, GLint, POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:268
aglDevicesOfPixelFormat = _link_function('aglDevicesOfPixelFormat', POINTER(AGLDevice), [AGLPixelFormat, POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:273
aglQueryRendererInfo = _link_function('aglQueryRendererInfo', AGLRendererInfo, [POINTER(AGLDevice), GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:274
aglDestroyRendererInfo = _link_function('aglDestroyRendererInfo', None, [AGLRendererInfo], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:275
aglNextRendererInfo = _link_function('aglNextRendererInfo', AGLRendererInfo, [AGLRendererInfo], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:276
aglDescribeRenderer = _link_function('aglDescribeRenderer', GLboolean, [AGLRendererInfo, GLint, POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:281
aglCreateContext = _link_function('aglCreateContext', AGLContext, [AGLPixelFormat, AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:282
aglDestroyContext = _link_function('aglDestroyContext', GLboolean, [AGLContext], None)
GLuint = c_ulong # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:51
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:283
aglCopyContext = _link_function('aglCopyContext', GLboolean, [AGLContext, AGLContext, GLuint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:284
aglUpdateContext = _link_function('aglUpdateContext', GLboolean, [AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:289
aglSetCurrentContext = _link_function('aglSetCurrentContext', GLboolean, [AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:290
aglGetCurrentContext = _link_function('aglGetCurrentContext', AGLContext, [], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:295
aglSetDrawable = _link_function('aglSetDrawable', GLboolean, [AGLContext, AGLDrawable], None)
GLsizei = c_long # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:48
GLvoid = None # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:56
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:296
aglSetOffScreen = _link_function('aglSetOffScreen', GLboolean, [AGLContext, GLsizei, GLsizei, GLsizei, POINTER(GLvoid)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:297
aglSetFullScreen = _link_function('aglSetFullScreen', GLboolean, [AGLContext, GLsizei, GLsizei, GLsizei, GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:298
aglGetDrawable = _link_function('aglGetDrawable', AGLDrawable, [AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:303
aglSetVirtualScreen = _link_function('aglSetVirtualScreen', GLboolean, [AGLContext, GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:304
aglGetVirtualScreen = _link_function('aglGetVirtualScreen', GLint, [AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:309
aglGetVersion = _link_function('aglGetVersion', None, [POINTER(GLint), POINTER(GLint)], None)
GLenum = c_ulong # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:42
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:314
aglConfigure = _link_function('aglConfigure', GLboolean, [GLenum, GLuint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:319
aglSwapBuffers = _link_function('aglSwapBuffers', None, [AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:324
aglEnable = _link_function('aglEnable', GLboolean, [AGLContext, GLenum], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:325
aglDisable = _link_function('aglDisable', GLboolean, [AGLContext, GLenum], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:326
aglIsEnabled = _link_function('aglIsEnabled', GLboolean, [AGLContext, GLenum], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:327
aglSetInteger = _link_function('aglSetInteger', GLboolean, [AGLContext, GLenum, POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:328
aglGetInteger = _link_function('aglGetInteger', GLboolean, [AGLContext, GLenum, POINTER(GLint)], None)
Style = c_ubyte # /System/Library/Frameworks/CoreServices.framework/Headers/../Frameworks/CarbonCore.framework/Headers/MacTypes.h:524
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:333
aglUseFont = _link_function('aglUseFont', GLboolean, [AGLContext, GLint, Style, GLint, GLint, GLint, GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:338
aglGetError = _link_function('aglGetError', GLenum, [], None)
GLubyte = c_ubyte # /System/Library/Frameworks/OpenGL.framework/Headers/gl.h:49
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:339
aglErrorString = _link_function('aglErrorString', POINTER(GLubyte), [GLenum], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:344
aglResetLibrary = _link_function('aglResetLibrary', None, [], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:349
aglSurfaceTexture = _link_function('aglSurfaceTexture', None, [AGLContext, GLenum, GLenum, AGLContext], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:354
aglCreatePBuffer = _link_function('aglCreatePBuffer', GLboolean, [GLint, GLint, GLenum, GLenum, c_long, POINTER(AGLPbuffer)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:355
aglDestroyPBuffer = _link_function('aglDestroyPBuffer', GLboolean, [AGLPbuffer], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:356
aglDescribePBuffer = _link_function('aglDescribePBuffer', GLboolean, [AGLPbuffer, POINTER(GLint), POINTER(GLint), POINTER(GLenum), POINTER(GLenum), POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:357
aglTexImagePBuffer = _link_function('aglTexImagePBuffer', GLboolean, [AGLContext, AGLPbuffer, GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:362
aglSetPBuffer = _link_function('aglSetPBuffer', GLboolean, [AGLContext, AGLPbuffer, GLint, GLint, GLint], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:363
aglGetPBuffer = _link_function('aglGetPBuffer', GLboolean, [AGLContext, POINTER(AGLPbuffer), POINTER(GLint), POINTER(GLint), POINTER(GLint)], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:368
aglGetCGLContext = _link_function('aglGetCGLContext', GLboolean, [AGLContext, POINTER(POINTER(None))], None)
# /System/Library/Frameworks/AGL.framework/Headers/agl.h:369
aglGetCGLPixelFormat = _link_function('aglGetCGLPixelFormat', GLboolean, [AGLPixelFormat, POINTER(POINTER(None))], None)
__all__ = ['AGL_VERSION_2_0', 'AGLDevice', 'AGLDrawable', 'AGLRendererInfo',
'AGLPixelFormat', 'AGLContext', 'AGLPbuffer', 'AGL_NONE', 'AGL_ALL_RENDERERS',
'AGL_BUFFER_SIZE', 'AGL_LEVEL', 'AGL_RGBA', 'AGL_DOUBLEBUFFER', 'AGL_STEREO',
'AGL_AUX_BUFFERS', 'AGL_RED_SIZE', 'AGL_GREEN_SIZE', 'AGL_BLUE_SIZE',
'AGL_ALPHA_SIZE', 'AGL_DEPTH_SIZE', 'AGL_STENCIL_SIZE', 'AGL_ACCUM_RED_SIZE',
'AGL_ACCUM_GREEN_SIZE', 'AGL_ACCUM_BLUE_SIZE', 'AGL_ACCUM_ALPHA_SIZE',
'AGL_PIXEL_SIZE', 'AGL_MINIMUM_POLICY', 'AGL_MAXIMUM_POLICY', 'AGL_OFFSCREEN',
'AGL_FULLSCREEN', 'AGL_SAMPLE_BUFFERS_ARB', 'AGL_SAMPLES_ARB',
'AGL_AUX_DEPTH_STENCIL', 'AGL_COLOR_FLOAT', 'AGL_MULTISAMPLE',
'AGL_SUPERSAMPLE', 'AGL_SAMPLE_ALPHA', 'AGL_RENDERER_ID',
'AGL_SINGLE_RENDERER', 'AGL_NO_RECOVERY', 'AGL_ACCELERATED',
'AGL_CLOSEST_POLICY', 'AGL_ROBUST', 'AGL_BACKING_STORE', 'AGL_MP_SAFE',
'AGL_WINDOW', 'AGL_MULTISCREEN', 'AGL_VIRTUAL_SCREEN', 'AGL_COMPLIANT',
'AGL_PBUFFER', 'AGL_BUFFER_MODES', 'AGL_MIN_LEVEL', 'AGL_MAX_LEVEL',
'AGL_COLOR_MODES', 'AGL_ACCUM_MODES', 'AGL_DEPTH_MODES', 'AGL_STENCIL_MODES',
'AGL_MAX_AUX_BUFFERS', 'AGL_VIDEO_MEMORY', 'AGL_TEXTURE_MEMORY',
'AGL_RENDERER_COUNT', 'AGL_SWAP_RECT', 'AGL_BUFFER_RECT', 'AGL_SWAP_LIMIT',
'AGL_COLORMAP_TRACKING', 'AGL_COLORMAP_ENTRY', 'AGL_RASTERIZATION',
'AGL_SWAP_INTERVAL', 'AGL_STATE_VALIDATION', 'AGL_BUFFER_NAME',
'AGL_ORDER_CONTEXT_TO_FRONT', 'AGL_CONTEXT_SURFACE_ID',
'AGL_CONTEXT_DISPLAY_ID', 'AGL_SURFACE_ORDER', 'AGL_SURFACE_OPACITY',
'AGL_CLIP_REGION', 'AGL_FS_CAPTURE_SINGLE', 'AGL_SURFACE_BACKING_SIZE',
'AGL_ENABLE_SURFACE_BACKING_SIZE', 'AGL_SURFACE_VOLATILE',
'AGL_FORMAT_CACHE_SIZE', 'AGL_CLEAR_FORMAT_CACHE', 'AGL_RETAIN_RENDERERS',
'AGL_MONOSCOPIC_BIT', 'AGL_STEREOSCOPIC_BIT', 'AGL_SINGLEBUFFER_BIT',
'AGL_DOUBLEBUFFER_BIT', 'AGL_0_BIT', 'AGL_1_BIT', 'AGL_2_BIT', 'AGL_3_BIT',
'AGL_4_BIT', 'AGL_5_BIT', 'AGL_6_BIT', 'AGL_8_BIT', 'AGL_10_BIT',
'AGL_12_BIT', 'AGL_16_BIT', 'AGL_24_BIT', 'AGL_32_BIT', 'AGL_48_BIT',
'AGL_64_BIT', 'AGL_96_BIT', 'AGL_128_BIT', 'AGL_RGB8_BIT', 'AGL_RGB8_A8_BIT',
'AGL_BGR233_BIT', 'AGL_BGR233_A8_BIT', 'AGL_RGB332_BIT', 'AGL_RGB332_A8_BIT',
'AGL_RGB444_BIT', 'AGL_ARGB4444_BIT', 'AGL_RGB444_A8_BIT', 'AGL_RGB555_BIT',
'AGL_ARGB1555_BIT', 'AGL_RGB555_A8_BIT', 'AGL_RGB565_BIT',
'AGL_RGB565_A8_BIT', 'AGL_RGB888_BIT', 'AGL_ARGB8888_BIT',
'AGL_RGB888_A8_BIT', 'AGL_RGB101010_BIT', 'AGL_ARGB2101010_BIT',
'AGL_RGB101010_A8_BIT', 'AGL_RGB121212_BIT', 'AGL_ARGB12121212_BIT',
'AGL_RGB161616_BIT', 'AGL_ARGB16161616_BIT', 'AGL_INDEX8_BIT',
'AGL_INDEX16_BIT', 'AGL_RGBFLOAT64_BIT', 'AGL_RGBAFLOAT64_BIT',
'AGL_RGBFLOAT128_BIT', 'AGL_RGBAFLOAT128_BIT', 'AGL_RGBFLOAT256_BIT',
'AGL_RGBAFLOAT256_BIT', 'AGL_NO_ERROR', 'AGL_BAD_ATTRIBUTE',
'AGL_BAD_PROPERTY', 'AGL_BAD_PIXELFMT', 'AGL_BAD_RENDINFO', 'AGL_BAD_CONTEXT',
'AGL_BAD_DRAWABLE', 'AGL_BAD_GDEV', 'AGL_BAD_STATE', 'AGL_BAD_VALUE',
'AGL_BAD_MATCH', 'AGL_BAD_ENUM', 'AGL_BAD_OFFSCREEN', 'AGL_BAD_FULLSCREEN',
'AGL_BAD_WINDOW', 'AGL_BAD_POINTER', 'AGL_BAD_MODULE', 'AGL_BAD_ALLOC',
'AGL_BAD_CONNECTION', 'aglChoosePixelFormat', 'aglDestroyPixelFormat',
'aglNextPixelFormat', 'aglDescribePixelFormat', 'aglDevicesOfPixelFormat',
'aglQueryRendererInfo', 'aglDestroyRendererInfo', 'aglNextRendererInfo',
'aglDescribeRenderer', 'aglCreateContext', 'aglDestroyContext',
'aglCopyContext', 'aglUpdateContext', 'aglSetCurrentContext',
'aglGetCurrentContext', 'aglSetDrawable', 'aglSetOffScreen',
'aglSetFullScreen', 'aglGetDrawable', 'aglSetVirtualScreen',
'aglGetVirtualScreen', 'aglGetVersion', 'aglConfigure', 'aglSwapBuffers',
'aglEnable', 'aglDisable', 'aglIsEnabled', 'aglSetInteger', 'aglGetInteger',
'aglUseFont', 'aglGetError', 'aglErrorString', 'aglResetLibrary',
'aglSurfaceTexture', 'aglCreatePBuffer', 'aglDestroyPBuffer',
'aglDescribePBuffer', 'aglTexImagePBuffer', 'aglSetPBuffer', 'aglGetPBuffer',
'aglGetCGLContext', 'aglGetCGLPixelFormat']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Information about version and extensions of current GL implementation.
Usage::
from pyglet.gl import gl_info
if gl_info.have_extension('GL_NV_register_combiners'):
# ...
If you are using more than one context, you can set up a separate GLInfo
object for each context. Call `set_active_context` after switching to the
context::
from pyglet.gl.gl_info import GLInfo
info = GLInfo()
info.set_active_context()
if info.have_version(2, 1):
# ...
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from ctypes import *
import warnings
from pyglet.gl.gl import *
from pyglet.compat import asstr
class GLInfo(object):
'''Information interface for a single GL context.
A default instance is created automatically when the first OpenGL context
is created. You can use the module functions as a convenience for
this default instance's methods.
If you are using more than one context, you must call `set_active_context`
when the context is active for this `GLInfo` instance.
'''
have_context = False
version = '0.0.0'
vendor = ''
renderer = ''
extensions = set()
_have_info = False
def set_active_context(self):
'''Store information for the currently active context.
This method is called automatically for the default context.
'''
self.have_context = True
if not self._have_info:
self.vendor = asstr(cast(glGetString(GL_VENDOR), c_char_p).value)
self.renderer = asstr(cast(glGetString(GL_RENDERER),
c_char_p).value)
self.version = asstr(cast(glGetString(GL_VERSION), c_char_p).value)
if self.have_version(3):
from pyglet.gl.glext_arb import glGetStringi, GL_NUM_EXTENSIONS
num_extensions = GLint()
glGetIntegerv(GL_NUM_EXTENSIONS, num_extensions)
self.extensions = (asstr(cast(glGetStringi(GL_EXTENSIONS, i),
c_char_p).value) for i in range(num_extensions.value))
else:
self.extensions = asstr(cast(glGetString(GL_EXTENSIONS),
c_char_p).value).split()
if self.extensions:
self.extensions = set(self.extensions)
self._have_info = True
def remove_active_context(self):
self.have_context = False
self._have_info = False
def have_extension(self, extension):
'''Determine if an OpenGL extension is available.
:Parameters:
`extension` : str
The name of the extension to test for, including its
``GL_`` prefix.
:return: True if the extension is provided by the driver.
:rtype: bool
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return extension in self.extensions
def get_extensions(self):
'''Get a list of available OpenGL extensions.
:return: a list of the available extensions.
:rtype: list of str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.extensions
def get_version(self):
'''Get the current OpenGL version.
:return: the OpenGL version
:rtype: str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.version
def have_version(self, major, minor=0, release=0):
'''Determine if a version of OpenGL is supported.
:Parameters:
`major` : int
The major revision number (typically 1 or 2).
`minor` : int
The minor revision number.
`release` : int
The release number.
:rtype: bool
:return: True if the requested or a later version is supported.
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
ver = '%s.0.0' % self.version.split(' ', 1)[0]
imajor, iminor, irelease = [int(v) for v in ver.split('.', 3)[:3]]
return imajor > major or \
(imajor == major and iminor > minor) or \
(imajor == major and iminor == minor and irelease >= release)
def get_renderer(self):
'''Determine the renderer string of the OpenGL context.
:rtype: str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.renderer
def get_vendor(self):
'''Determine the vendor string of the OpenGL context.
:rtype: str
'''
if not self.have_context:
warnings.warn('No GL context created yet.')
return self.vendor
# Single instance useful for apps with only a single context (or all contexts
# have same GL driver, common case).
_gl_info = GLInfo()
set_active_context = _gl_info.set_active_context
remove_active_context = _gl_info.remove_active_context
have_extension = _gl_info.have_extension
get_extensions = _gl_info.get_extensions
get_version = _gl_info.get_version
have_version = _gl_info.have_version
get_renderer = _gl_info.get_renderer
get_vendor = _gl_info.get_vendor
def have_context():
'''Determine if a default OpenGL context has been set yet.
:rtype: bool
'''
return _gl_info.have_context
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for http://oss.sgi.com/projects/ogl-sample/ABI/wglext.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: gengl.py 601 2007-02-04 05:36:59Z Alex.Holkner $'
from ctypes import *
from pyglet.gl.lib import link_WGL as _link_function
from pyglet.gl.lib import c_ptrdiff_t, c_void
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for http://www.opengl.org/registry/api/wglext.h
# H (C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:7)
# H (C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:7)
WIN32_LEAN_AND_MEAN = 1 # http://www.opengl.org/registry/api/wglext.h:34
WGL_WGLEXT_VERSION = 11 # http://www.opengl.org/registry/api/wglext.h:53
# ARB_buffer_region (http://www.opengl.org/registry/api/wglext.h:55)
WGL_FRONT_COLOR_BUFFER_BIT_ARB = 1 # http://www.opengl.org/registry/api/wglext.h:56
WGL_BACK_COLOR_BUFFER_BIT_ARB = 2 # http://www.opengl.org/registry/api/wglext.h:57
WGL_DEPTH_BUFFER_BIT_ARB = 4 # http://www.opengl.org/registry/api/wglext.h:58
WGL_STENCIL_BUFFER_BIT_ARB = 8 # http://www.opengl.org/registry/api/wglext.h:59
# ARB_multisample (http://www.opengl.org/registry/api/wglext.h:62)
WGL_SAMPLE_BUFFERS_ARB = 8257 # http://www.opengl.org/registry/api/wglext.h:63
WGL_SAMPLES_ARB = 8258 # http://www.opengl.org/registry/api/wglext.h:64
# ARB_extensions_string (http://www.opengl.org/registry/api/wglext.h:67)
# ARB_pixel_format (http://www.opengl.org/registry/api/wglext.h:70)
WGL_NUMBER_PIXEL_FORMATS_ARB = 8192 # http://www.opengl.org/registry/api/wglext.h:71
WGL_DRAW_TO_WINDOW_ARB = 8193 # http://www.opengl.org/registry/api/wglext.h:72
WGL_DRAW_TO_BITMAP_ARB = 8194 # http://www.opengl.org/registry/api/wglext.h:73
WGL_ACCELERATION_ARB = 8195 # http://www.opengl.org/registry/api/wglext.h:74
WGL_NEED_PALETTE_ARB = 8196 # http://www.opengl.org/registry/api/wglext.h:75
WGL_NEED_SYSTEM_PALETTE_ARB = 8197 # http://www.opengl.org/registry/api/wglext.h:76
WGL_SWAP_LAYER_BUFFERS_ARB = 8198 # http://www.opengl.org/registry/api/wglext.h:77
WGL_SWAP_METHOD_ARB = 8199 # http://www.opengl.org/registry/api/wglext.h:78
WGL_NUMBER_OVERLAYS_ARB = 8200 # http://www.opengl.org/registry/api/wglext.h:79
WGL_NUMBER_UNDERLAYS_ARB = 8201 # http://www.opengl.org/registry/api/wglext.h:80
WGL_TRANSPARENT_ARB = 8202 # http://www.opengl.org/registry/api/wglext.h:81
WGL_TRANSPARENT_RED_VALUE_ARB = 8247 # http://www.opengl.org/registry/api/wglext.h:82
WGL_TRANSPARENT_GREEN_VALUE_ARB = 8248 # http://www.opengl.org/registry/api/wglext.h:83
WGL_TRANSPARENT_BLUE_VALUE_ARB = 8249 # http://www.opengl.org/registry/api/wglext.h:84
WGL_TRANSPARENT_ALPHA_VALUE_ARB = 8250 # http://www.opengl.org/registry/api/wglext.h:85
WGL_TRANSPARENT_INDEX_VALUE_ARB = 8251 # http://www.opengl.org/registry/api/wglext.h:86
WGL_SHARE_DEPTH_ARB = 8204 # http://www.opengl.org/registry/api/wglext.h:87
WGL_SHARE_STENCIL_ARB = 8205 # http://www.opengl.org/registry/api/wglext.h:88
WGL_SHARE_ACCUM_ARB = 8206 # http://www.opengl.org/registry/api/wglext.h:89
WGL_SUPPORT_GDI_ARB = 8207 # http://www.opengl.org/registry/api/wglext.h:90
WGL_SUPPORT_OPENGL_ARB = 8208 # http://www.opengl.org/registry/api/wglext.h:91
WGL_DOUBLE_BUFFER_ARB = 8209 # http://www.opengl.org/registry/api/wglext.h:92
WGL_STEREO_ARB = 8210 # http://www.opengl.org/registry/api/wglext.h:93
WGL_PIXEL_TYPE_ARB = 8211 # http://www.opengl.org/registry/api/wglext.h:94
WGL_COLOR_BITS_ARB = 8212 # http://www.opengl.org/registry/api/wglext.h:95
WGL_RED_BITS_ARB = 8213 # http://www.opengl.org/registry/api/wglext.h:96
WGL_RED_SHIFT_ARB = 8214 # http://www.opengl.org/registry/api/wglext.h:97
WGL_GREEN_BITS_ARB = 8215 # http://www.opengl.org/registry/api/wglext.h:98
WGL_GREEN_SHIFT_ARB = 8216 # http://www.opengl.org/registry/api/wglext.h:99
WGL_BLUE_BITS_ARB = 8217 # http://www.opengl.org/registry/api/wglext.h:100
WGL_BLUE_SHIFT_ARB = 8218 # http://www.opengl.org/registry/api/wglext.h:101
WGL_ALPHA_BITS_ARB = 8219 # http://www.opengl.org/registry/api/wglext.h:102
WGL_ALPHA_SHIFT_ARB = 8220 # http://www.opengl.org/registry/api/wglext.h:103
WGL_ACCUM_BITS_ARB = 8221 # http://www.opengl.org/registry/api/wglext.h:104
WGL_ACCUM_RED_BITS_ARB = 8222 # http://www.opengl.org/registry/api/wglext.h:105
WGL_ACCUM_GREEN_BITS_ARB = 8223 # http://www.opengl.org/registry/api/wglext.h:106
WGL_ACCUM_BLUE_BITS_ARB = 8224 # http://www.opengl.org/registry/api/wglext.h:107
WGL_ACCUM_ALPHA_BITS_ARB = 8225 # http://www.opengl.org/registry/api/wglext.h:108
WGL_DEPTH_BITS_ARB = 8226 # http://www.opengl.org/registry/api/wglext.h:109
WGL_STENCIL_BITS_ARB = 8227 # http://www.opengl.org/registry/api/wglext.h:110
WGL_AUX_BUFFERS_ARB = 8228 # http://www.opengl.org/registry/api/wglext.h:111
WGL_NO_ACCELERATION_ARB = 8229 # http://www.opengl.org/registry/api/wglext.h:112
WGL_GENERIC_ACCELERATION_ARB = 8230 # http://www.opengl.org/registry/api/wglext.h:113
WGL_FULL_ACCELERATION_ARB = 8231 # http://www.opengl.org/registry/api/wglext.h:114
WGL_SWAP_EXCHANGE_ARB = 8232 # http://www.opengl.org/registry/api/wglext.h:115
WGL_SWAP_COPY_ARB = 8233 # http://www.opengl.org/registry/api/wglext.h:116
WGL_SWAP_UNDEFINED_ARB = 8234 # http://www.opengl.org/registry/api/wglext.h:117
WGL_TYPE_RGBA_ARB = 8235 # http://www.opengl.org/registry/api/wglext.h:118
WGL_TYPE_COLORINDEX_ARB = 8236 # http://www.opengl.org/registry/api/wglext.h:119
# ARB_make_current_read (http://www.opengl.org/registry/api/wglext.h:122)
ERROR_INVALID_PIXEL_TYPE_ARB = 8259 # http://www.opengl.org/registry/api/wglext.h:123
ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 8276 # http://www.opengl.org/registry/api/wglext.h:124
# ARB_pbuffer (http://www.opengl.org/registry/api/wglext.h:127)
WGL_DRAW_TO_PBUFFER_ARB = 8237 # http://www.opengl.org/registry/api/wglext.h:128
WGL_MAX_PBUFFER_PIXELS_ARB = 8238 # http://www.opengl.org/registry/api/wglext.h:129
WGL_MAX_PBUFFER_WIDTH_ARB = 8239 # http://www.opengl.org/registry/api/wglext.h:130
WGL_MAX_PBUFFER_HEIGHT_ARB = 8240 # http://www.opengl.org/registry/api/wglext.h:131
WGL_PBUFFER_LARGEST_ARB = 8243 # http://www.opengl.org/registry/api/wglext.h:132
WGL_PBUFFER_WIDTH_ARB = 8244 # http://www.opengl.org/registry/api/wglext.h:133
WGL_PBUFFER_HEIGHT_ARB = 8245 # http://www.opengl.org/registry/api/wglext.h:134
WGL_PBUFFER_LOST_ARB = 8246 # http://www.opengl.org/registry/api/wglext.h:135
# ARB_render_texture (http://www.opengl.org/registry/api/wglext.h:138)
WGL_BIND_TO_TEXTURE_RGB_ARB = 8304 # http://www.opengl.org/registry/api/wglext.h:139
WGL_BIND_TO_TEXTURE_RGBA_ARB = 8305 # http://www.opengl.org/registry/api/wglext.h:140
WGL_TEXTURE_FORMAT_ARB = 8306 # http://www.opengl.org/registry/api/wglext.h:141
WGL_TEXTURE_TARGET_ARB = 8307 # http://www.opengl.org/registry/api/wglext.h:142
WGL_MIPMAP_TEXTURE_ARB = 8308 # http://www.opengl.org/registry/api/wglext.h:143
WGL_TEXTURE_RGB_ARB = 8309 # http://www.opengl.org/registry/api/wglext.h:144
WGL_TEXTURE_RGBA_ARB = 8310 # http://www.opengl.org/registry/api/wglext.h:145
WGL_NO_TEXTURE_ARB = 8311 # http://www.opengl.org/registry/api/wglext.h:146
WGL_TEXTURE_CUBE_MAP_ARB = 8312 # http://www.opengl.org/registry/api/wglext.h:147
WGL_TEXTURE_1D_ARB = 8313 # http://www.opengl.org/registry/api/wglext.h:148
WGL_TEXTURE_2D_ARB = 8314 # http://www.opengl.org/registry/api/wglext.h:149
WGL_MIPMAP_LEVEL_ARB = 8315 # http://www.opengl.org/registry/api/wglext.h:150
WGL_CUBE_MAP_FACE_ARB = 8316 # http://www.opengl.org/registry/api/wglext.h:151
WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 8317 # http://www.opengl.org/registry/api/wglext.h:152
WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 8318 # http://www.opengl.org/registry/api/wglext.h:153
WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 8319 # http://www.opengl.org/registry/api/wglext.h:154
WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 8320 # http://www.opengl.org/registry/api/wglext.h:155
WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 8321 # http://www.opengl.org/registry/api/wglext.h:156
WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 8322 # http://www.opengl.org/registry/api/wglext.h:157
WGL_FRONT_LEFT_ARB = 8323 # http://www.opengl.org/registry/api/wglext.h:158
WGL_FRONT_RIGHT_ARB = 8324 # http://www.opengl.org/registry/api/wglext.h:159
WGL_BACK_LEFT_ARB = 8325 # http://www.opengl.org/registry/api/wglext.h:160
WGL_BACK_RIGHT_ARB = 8326 # http://www.opengl.org/registry/api/wglext.h:161
WGL_AUX0_ARB = 8327 # http://www.opengl.org/registry/api/wglext.h:162
WGL_AUX1_ARB = 8328 # http://www.opengl.org/registry/api/wglext.h:163
WGL_AUX2_ARB = 8329 # http://www.opengl.org/registry/api/wglext.h:164
WGL_AUX3_ARB = 8330 # http://www.opengl.org/registry/api/wglext.h:165
WGL_AUX4_ARB = 8331 # http://www.opengl.org/registry/api/wglext.h:166
WGL_AUX5_ARB = 8332 # http://www.opengl.org/registry/api/wglext.h:167
WGL_AUX6_ARB = 8333 # http://www.opengl.org/registry/api/wglext.h:168
WGL_AUX7_ARB = 8334 # http://www.opengl.org/registry/api/wglext.h:169
WGL_AUX8_ARB = 8335 # http://www.opengl.org/registry/api/wglext.h:170
WGL_AUX9_ARB = 8336 # http://www.opengl.org/registry/api/wglext.h:171
# ARB_pixel_format_float (http://www.opengl.org/registry/api/wglext.h:174)
WGL_TYPE_RGBA_FLOAT_ARB = 8608 # http://www.opengl.org/registry/api/wglext.h:175
# ARB_create_context (http://www.opengl.org/registry/api/wglext.h:178)
WGL_CONTEXT_DEBUG_BIT_ARB = 1 # http://www.opengl.org/registry/api/wglext.h:179
WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 2 # http://www.opengl.org/registry/api/wglext.h:180
WGL_CONTEXT_MAJOR_VERSION_ARB = 8337 # http://www.opengl.org/registry/api/wglext.h:181
WGL_CONTEXT_MINOR_VERSION_ARB = 8338 # http://www.opengl.org/registry/api/wglext.h:182
WGL_CONTEXT_LAYER_PLANE_ARB = 8339 # http://www.opengl.org/registry/api/wglext.h:183
WGL_CONTEXT_FLAGS_ARB = 8340 # http://www.opengl.org/registry/api/wglext.h:184
ERROR_INVALID_VERSION_ARB = 8341 # http://www.opengl.org/registry/api/wglext.h:185
# EXT_make_current_read (http://www.opengl.org/registry/api/wglext.h:188)
ERROR_INVALID_PIXEL_TYPE_EXT = 8259 # http://www.opengl.org/registry/api/wglext.h:189
# EXT_pixel_format (http://www.opengl.org/registry/api/wglext.h:192)
WGL_NUMBER_PIXEL_FORMATS_EXT = 8192 # http://www.opengl.org/registry/api/wglext.h:193
WGL_DRAW_TO_WINDOW_EXT = 8193 # http://www.opengl.org/registry/api/wglext.h:194
WGL_DRAW_TO_BITMAP_EXT = 8194 # http://www.opengl.org/registry/api/wglext.h:195
WGL_ACCELERATION_EXT = 8195 # http://www.opengl.org/registry/api/wglext.h:196
WGL_NEED_PALETTE_EXT = 8196 # http://www.opengl.org/registry/api/wglext.h:197
WGL_NEED_SYSTEM_PALETTE_EXT = 8197 # http://www.opengl.org/registry/api/wglext.h:198
WGL_SWAP_LAYER_BUFFERS_EXT = 8198 # http://www.opengl.org/registry/api/wglext.h:199
WGL_SWAP_METHOD_EXT = 8199 # http://www.opengl.org/registry/api/wglext.h:200
WGL_NUMBER_OVERLAYS_EXT = 8200 # http://www.opengl.org/registry/api/wglext.h:201
WGL_NUMBER_UNDERLAYS_EXT = 8201 # http://www.opengl.org/registry/api/wglext.h:202
WGL_TRANSPARENT_EXT = 8202 # http://www.opengl.org/registry/api/wglext.h:203
WGL_TRANSPARENT_VALUE_EXT = 8203 # http://www.opengl.org/registry/api/wglext.h:204
WGL_SHARE_DEPTH_EXT = 8204 # http://www.opengl.org/registry/api/wglext.h:205
WGL_SHARE_STENCIL_EXT = 8205 # http://www.opengl.org/registry/api/wglext.h:206
WGL_SHARE_ACCUM_EXT = 8206 # http://www.opengl.org/registry/api/wglext.h:207
WGL_SUPPORT_GDI_EXT = 8207 # http://www.opengl.org/registry/api/wglext.h:208
WGL_SUPPORT_OPENGL_EXT = 8208 # http://www.opengl.org/registry/api/wglext.h:209
WGL_DOUBLE_BUFFER_EXT = 8209 # http://www.opengl.org/registry/api/wglext.h:210
WGL_STEREO_EXT = 8210 # http://www.opengl.org/registry/api/wglext.h:211
WGL_PIXEL_TYPE_EXT = 8211 # http://www.opengl.org/registry/api/wglext.h:212
WGL_COLOR_BITS_EXT = 8212 # http://www.opengl.org/registry/api/wglext.h:213
WGL_RED_BITS_EXT = 8213 # http://www.opengl.org/registry/api/wglext.h:214
WGL_RED_SHIFT_EXT = 8214 # http://www.opengl.org/registry/api/wglext.h:215
WGL_GREEN_BITS_EXT = 8215 # http://www.opengl.org/registry/api/wglext.h:216
WGL_GREEN_SHIFT_EXT = 8216 # http://www.opengl.org/registry/api/wglext.h:217
WGL_BLUE_BITS_EXT = 8217 # http://www.opengl.org/registry/api/wglext.h:218
WGL_BLUE_SHIFT_EXT = 8218 # http://www.opengl.org/registry/api/wglext.h:219
WGL_ALPHA_BITS_EXT = 8219 # http://www.opengl.org/registry/api/wglext.h:220
WGL_ALPHA_SHIFT_EXT = 8220 # http://www.opengl.org/registry/api/wglext.h:221
WGL_ACCUM_BITS_EXT = 8221 # http://www.opengl.org/registry/api/wglext.h:222
WGL_ACCUM_RED_BITS_EXT = 8222 # http://www.opengl.org/registry/api/wglext.h:223
WGL_ACCUM_GREEN_BITS_EXT = 8223 # http://www.opengl.org/registry/api/wglext.h:224
WGL_ACCUM_BLUE_BITS_EXT = 8224 # http://www.opengl.org/registry/api/wglext.h:225
WGL_ACCUM_ALPHA_BITS_EXT = 8225 # http://www.opengl.org/registry/api/wglext.h:226
WGL_DEPTH_BITS_EXT = 8226 # http://www.opengl.org/registry/api/wglext.h:227
WGL_STENCIL_BITS_EXT = 8227 # http://www.opengl.org/registry/api/wglext.h:228
WGL_AUX_BUFFERS_EXT = 8228 # http://www.opengl.org/registry/api/wglext.h:229
WGL_NO_ACCELERATION_EXT = 8229 # http://www.opengl.org/registry/api/wglext.h:230
WGL_GENERIC_ACCELERATION_EXT = 8230 # http://www.opengl.org/registry/api/wglext.h:231
WGL_FULL_ACCELERATION_EXT = 8231 # http://www.opengl.org/registry/api/wglext.h:232
WGL_SWAP_EXCHANGE_EXT = 8232 # http://www.opengl.org/registry/api/wglext.h:233
WGL_SWAP_COPY_EXT = 8233 # http://www.opengl.org/registry/api/wglext.h:234
WGL_SWAP_UNDEFINED_EXT = 8234 # http://www.opengl.org/registry/api/wglext.h:235
WGL_TYPE_RGBA_EXT = 8235 # http://www.opengl.org/registry/api/wglext.h:236
WGL_TYPE_COLORINDEX_EXT = 8236 # http://www.opengl.org/registry/api/wglext.h:237
# EXT_pbuffer (http://www.opengl.org/registry/api/wglext.h:240)
WGL_DRAW_TO_PBUFFER_EXT = 8237 # http://www.opengl.org/registry/api/wglext.h:241
WGL_MAX_PBUFFER_PIXELS_EXT = 8238 # http://www.opengl.org/registry/api/wglext.h:242
WGL_MAX_PBUFFER_WIDTH_EXT = 8239 # http://www.opengl.org/registry/api/wglext.h:243
WGL_MAX_PBUFFER_HEIGHT_EXT = 8240 # http://www.opengl.org/registry/api/wglext.h:244
WGL_OPTIMAL_PBUFFER_WIDTH_EXT = 8241 # http://www.opengl.org/registry/api/wglext.h:245
WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = 8242 # http://www.opengl.org/registry/api/wglext.h:246
WGL_PBUFFER_LARGEST_EXT = 8243 # http://www.opengl.org/registry/api/wglext.h:247
WGL_PBUFFER_WIDTH_EXT = 8244 # http://www.opengl.org/registry/api/wglext.h:248
WGL_PBUFFER_HEIGHT_EXT = 8245 # http://www.opengl.org/registry/api/wglext.h:249
# EXT_depth_float (http://www.opengl.org/registry/api/wglext.h:252)
WGL_DEPTH_FLOAT_EXT = 8256 # http://www.opengl.org/registry/api/wglext.h:253
# 3DFX_multisample (http://www.opengl.org/registry/api/wglext.h:256)
WGL_SAMPLE_BUFFERS_3DFX = 8288 # http://www.opengl.org/registry/api/wglext.h:257
WGL_SAMPLES_3DFX = 8289 # http://www.opengl.org/registry/api/wglext.h:258
# EXT_multisample (http://www.opengl.org/registry/api/wglext.h:261)
WGL_SAMPLE_BUFFERS_EXT = 8257 # http://www.opengl.org/registry/api/wglext.h:262
WGL_SAMPLES_EXT = 8258 # http://www.opengl.org/registry/api/wglext.h:263
# I3D_digital_video_control (http://www.opengl.org/registry/api/wglext.h:266)
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 8272 # http://www.opengl.org/registry/api/wglext.h:267
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 8273 # http://www.opengl.org/registry/api/wglext.h:268
WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 8274 # http://www.opengl.org/registry/api/wglext.h:269
WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 8275 # http://www.opengl.org/registry/api/wglext.h:270
# I3D_gamma (http://www.opengl.org/registry/api/wglext.h:273)
WGL_GAMMA_TABLE_SIZE_I3D = 8270 # http://www.opengl.org/registry/api/wglext.h:274
WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 8271 # http://www.opengl.org/registry/api/wglext.h:275
# I3D_genlock (http://www.opengl.org/registry/api/wglext.h:278)
WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = 8260 # http://www.opengl.org/registry/api/wglext.h:279
WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = 8261 # http://www.opengl.org/registry/api/wglext.h:280
WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = 8262 # http://www.opengl.org/registry/api/wglext.h:281
WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = 8263 # http://www.opengl.org/registry/api/wglext.h:282
WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 8264 # http://www.opengl.org/registry/api/wglext.h:283
WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 8265 # http://www.opengl.org/registry/api/wglext.h:284
WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = 8266 # http://www.opengl.org/registry/api/wglext.h:285
WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = 8267 # http://www.opengl.org/registry/api/wglext.h:286
WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = 8268 # http://www.opengl.org/registry/api/wglext.h:287
# I3D_image_buffer (http://www.opengl.org/registry/api/wglext.h:290)
WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = 1 # http://www.opengl.org/registry/api/wglext.h:291
WGL_IMAGE_BUFFER_LOCK_I3D = 2 # http://www.opengl.org/registry/api/wglext.h:292
# I3D_swap_frame_lock (http://www.opengl.org/registry/api/wglext.h:295)
# NV_render_depth_texture (http://www.opengl.org/registry/api/wglext.h:298)
WGL_BIND_TO_TEXTURE_DEPTH_NV = 8355 # http://www.opengl.org/registry/api/wglext.h:299
WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 8356 # http://www.opengl.org/registry/api/wglext.h:300
WGL_DEPTH_TEXTURE_FORMAT_NV = 8357 # http://www.opengl.org/registry/api/wglext.h:301
WGL_TEXTURE_DEPTH_COMPONENT_NV = 8358 # http://www.opengl.org/registry/api/wglext.h:302
WGL_DEPTH_COMPONENT_NV = 8359 # http://www.opengl.org/registry/api/wglext.h:303
# NV_render_texture_rectangle (http://www.opengl.org/registry/api/wglext.h:306)
WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 8352 # http://www.opengl.org/registry/api/wglext.h:307
WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 8353 # http://www.opengl.org/registry/api/wglext.h:308
WGL_TEXTURE_RECTANGLE_NV = 8354 # http://www.opengl.org/registry/api/wglext.h:309
# ATI_pixel_format_float (http://www.opengl.org/registry/api/wglext.h:312)
WGL_TYPE_RGBA_FLOAT_ATI = 8608 # http://www.opengl.org/registry/api/wglext.h:313
# NV_float_buffer (http://www.opengl.org/registry/api/wglext.h:316)
WGL_FLOAT_COMPONENTS_NV = 8368 # http://www.opengl.org/registry/api/wglext.h:317
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 8369 # http://www.opengl.org/registry/api/wglext.h:318
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 8370 # http://www.opengl.org/registry/api/wglext.h:319
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 8371 # http://www.opengl.org/registry/api/wglext.h:320
WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 8372 # http://www.opengl.org/registry/api/wglext.h:321
WGL_TEXTURE_FLOAT_R_NV = 8373 # http://www.opengl.org/registry/api/wglext.h:322
WGL_TEXTURE_FLOAT_RG_NV = 8374 # http://www.opengl.org/registry/api/wglext.h:323
WGL_TEXTURE_FLOAT_RGB_NV = 8375 # http://www.opengl.org/registry/api/wglext.h:324
WGL_TEXTURE_FLOAT_RGBA_NV = 8376 # http://www.opengl.org/registry/api/wglext.h:325
# 3DL_stereo_control (http://www.opengl.org/registry/api/wglext.h:328)
WGL_STEREO_EMITTER_ENABLE_3DL = 8277 # http://www.opengl.org/registry/api/wglext.h:329
WGL_STEREO_EMITTER_DISABLE_3DL = 8278 # http://www.opengl.org/registry/api/wglext.h:330
WGL_STEREO_POLARITY_NORMAL_3DL = 8279 # http://www.opengl.org/registry/api/wglext.h:331
WGL_STEREO_POLARITY_INVERT_3DL = 8280 # http://www.opengl.org/registry/api/wglext.h:332
# EXT_pixel_format_packed_float (http://www.opengl.org/registry/api/wglext.h:335)
WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 8360 # http://www.opengl.org/registry/api/wglext.h:336
# EXT_framebuffer_sRGB (http://www.opengl.org/registry/api/wglext.h:339)
WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 8361 # http://www.opengl.org/registry/api/wglext.h:340
# NV_present_video (http://www.opengl.org/registry/api/wglext.h:343)
WGL_NUM_VIDEO_SLOTS_NV = 8432 # http://www.opengl.org/registry/api/wglext.h:344
# NV_video_out (http://www.opengl.org/registry/api/wglext.h:347)
WGL_BIND_TO_VIDEO_RGB_NV = 8384 # http://www.opengl.org/registry/api/wglext.h:348
WGL_BIND_TO_VIDEO_RGBA_NV = 8385 # http://www.opengl.org/registry/api/wglext.h:349
WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = 8386 # http://www.opengl.org/registry/api/wglext.h:350
WGL_VIDEO_OUT_COLOR_NV = 8387 # http://www.opengl.org/registry/api/wglext.h:351
WGL_VIDEO_OUT_ALPHA_NV = 8388 # http://www.opengl.org/registry/api/wglext.h:352
WGL_VIDEO_OUT_DEPTH_NV = 8389 # http://www.opengl.org/registry/api/wglext.h:353
WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = 8390 # http://www.opengl.org/registry/api/wglext.h:354
WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = 8391 # http://www.opengl.org/registry/api/wglext.h:355
WGL_VIDEO_OUT_FRAME = 8392 # http://www.opengl.org/registry/api/wglext.h:356
WGL_VIDEO_OUT_FIELD_1 = 8393 # http://www.opengl.org/registry/api/wglext.h:357
WGL_VIDEO_OUT_FIELD_2 = 8394 # http://www.opengl.org/registry/api/wglext.h:358
WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = 8395 # http://www.opengl.org/registry/api/wglext.h:359
WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = 8396 # http://www.opengl.org/registry/api/wglext.h:360
# NV_swap_group (http://www.opengl.org/registry/api/wglext.h:363)
# NV_gpu_affinity (http://www.opengl.org/registry/api/wglext.h:366)
WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 8400 # http://www.opengl.org/registry/api/wglext.h:367
WGL_ERROR_MISSING_AFFINITY_MASK_NV = 8401 # http://www.opengl.org/registry/api/wglext.h:368
# ARB_pbuffer (http://www.opengl.org/registry/api/wglext.h:374)
HANDLE = POINTER(None) # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:58
HPBUFFERARB = HANDLE # http://www.opengl.org/registry/api/wglext.h:375
# EXT_pbuffer (http://www.opengl.org/registry/api/wglext.h:377)
HPBUFFEREXT = HANDLE # http://www.opengl.org/registry/api/wglext.h:378
# NV_present_video (http://www.opengl.org/registry/api/wglext.h:380)
HVIDEOOUTPUTDEVICENV = HANDLE # http://www.opengl.org/registry/api/wglext.h:381
# NV_video_out (http://www.opengl.org/registry/api/wglext.h:383)
HPVIDEODEV = HANDLE # http://www.opengl.org/registry/api/wglext.h:384
# NV_gpu_affinity (http://www.opengl.org/registry/api/wglext.h:386)
HPGPUNV = HANDLE # http://www.opengl.org/registry/api/wglext.h:387
HGPUNV = HANDLE # http://www.opengl.org/registry/api/wglext.h:388
class struct__GPU_DEVICE(Structure):
__slots__ = [
'cb',
'DeviceName',
'DeviceString',
'Flags',
'rcVirtualScreen',
]
DWORD = c_ulong # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:54
CHAR = c_char # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:47
class struct_tagRECT(Structure):
__slots__ = [
'left',
'top',
'right',
'bottom',
]
LONG = c_long # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:53
struct_tagRECT._fields_ = [
('left', LONG),
('top', LONG),
('right', LONG),
('bottom', LONG),
]
RECT = struct_tagRECT # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:200
struct__GPU_DEVICE._fields_ = [
('cb', DWORD),
('DeviceName', CHAR * 32),
('DeviceString', CHAR * 128),
('Flags', DWORD),
('rcVirtualScreen', RECT),
]
GPU_DEVICE = struct__GPU_DEVICE # http://www.opengl.org/registry/api/wglext.h:396
PGPU_DEVICE = POINTER(struct__GPU_DEVICE) # http://www.opengl.org/registry/api/wglext.h:396
# ARB_buffer_region (http://www.opengl.org/registry/api/wglext.h:399)
WGL_ARB_buffer_region = 1 # http://www.opengl.org/registry/api/wglext.h:400
HDC = HANDLE # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:61
UINT = c_uint # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:50
# http://www.opengl.org/registry/api/wglext.h:402
wglCreateBufferRegionARB = _link_function('wglCreateBufferRegionARB', HANDLE, [HDC, c_int, UINT], 'ARB_buffer_region')
VOID = None # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:45
# http://www.opengl.org/registry/api/wglext.h:403
wglDeleteBufferRegionARB = _link_function('wglDeleteBufferRegionARB', VOID, [HANDLE], 'ARB_buffer_region')
BOOL = c_long # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:52
# http://www.opengl.org/registry/api/wglext.h:404
wglSaveBufferRegionARB = _link_function('wglSaveBufferRegionARB', BOOL, [HANDLE, c_int, c_int, c_int, c_int], 'ARB_buffer_region')
# http://www.opengl.org/registry/api/wglext.h:405
wglRestoreBufferRegionARB = _link_function('wglRestoreBufferRegionARB', BOOL, [HANDLE, c_int, c_int, c_int, c_int, c_int, c_int], 'ARB_buffer_region')
PFNWGLCREATEBUFFERREGIONARBPROC = CFUNCTYPE(HANDLE, HDC, c_int, UINT) # http://www.opengl.org/registry/api/wglext.h:407
PFNWGLDELETEBUFFERREGIONARBPROC = CFUNCTYPE(VOID, HANDLE) # http://www.opengl.org/registry/api/wglext.h:408
PFNWGLSAVEBUFFERREGIONARBPROC = CFUNCTYPE(BOOL, HANDLE, c_int, c_int, c_int, c_int) # http://www.opengl.org/registry/api/wglext.h:409
PFNWGLRESTOREBUFFERREGIONARBPROC = CFUNCTYPE(BOOL, HANDLE, c_int, c_int, c_int, c_int, c_int, c_int) # http://www.opengl.org/registry/api/wglext.h:410
# ARB_multisample (http://www.opengl.org/registry/api/wglext.h:413)
WGL_ARB_multisample = 1 # http://www.opengl.org/registry/api/wglext.h:414
# ARB_extensions_string (http://www.opengl.org/registry/api/wglext.h:417)
WGL_ARB_extensions_string = 1 # http://www.opengl.org/registry/api/wglext.h:418
# http://www.opengl.org/registry/api/wglext.h:420
wglGetExtensionsStringARB = _link_function('wglGetExtensionsStringARB', c_char_p, [HDC], 'ARB_extensions_string')
PFNWGLGETEXTENSIONSSTRINGARBPROC = CFUNCTYPE(c_char_p, HDC) # http://www.opengl.org/registry/api/wglext.h:422
# ARB_pixel_format (http://www.opengl.org/registry/api/wglext.h:425)
WGL_ARB_pixel_format = 1 # http://www.opengl.org/registry/api/wglext.h:426
# http://www.opengl.org/registry/api/wglext.h:428
wglGetPixelFormatAttribivARB = _link_function('wglGetPixelFormatAttribivARB', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)], 'ARB_pixel_format')
FLOAT = c_float # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:55
# http://www.opengl.org/registry/api/wglext.h:429
wglGetPixelFormatAttribfvARB = _link_function('wglGetPixelFormatAttribfvARB', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)], 'ARB_pixel_format')
# http://www.opengl.org/registry/api/wglext.h:430
wglChoosePixelFormatARB = _link_function('wglChoosePixelFormatARB', BOOL, [HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)], 'ARB_pixel_format')
PFNWGLGETPIXELFORMATATTRIBIVARBPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:432
PFNWGLGETPIXELFORMATATTRIBFVARBPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)) # http://www.opengl.org/registry/api/wglext.h:433
PFNWGLCHOOSEPIXELFORMATARBPROC = CFUNCTYPE(BOOL, HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:434
# ARB_make_current_read (http://www.opengl.org/registry/api/wglext.h:437)
WGL_ARB_make_current_read = 1 # http://www.opengl.org/registry/api/wglext.h:438
HGLRC = HANDLE # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:60
# http://www.opengl.org/registry/api/wglext.h:440
wglMakeContextCurrentARB = _link_function('wglMakeContextCurrentARB', BOOL, [HDC, HDC, HGLRC], 'ARB_make_current_read')
# http://www.opengl.org/registry/api/wglext.h:441
wglGetCurrentReadDCARB = _link_function('wglGetCurrentReadDCARB', HDC, [], 'ARB_make_current_read')
PFNWGLMAKECONTEXTCURRENTARBPROC = CFUNCTYPE(BOOL, HDC, HDC, HGLRC) # http://www.opengl.org/registry/api/wglext.h:443
PFNWGLGETCURRENTREADDCARBPROC = CFUNCTYPE(HDC) # http://www.opengl.org/registry/api/wglext.h:444
# ARB_pbuffer (http://www.opengl.org/registry/api/wglext.h:447)
WGL_ARB_pbuffer = 1 # http://www.opengl.org/registry/api/wglext.h:448
# http://www.opengl.org/registry/api/wglext.h:450
wglCreatePbufferARB = _link_function('wglCreatePbufferARB', HPBUFFERARB, [HDC, c_int, c_int, c_int, POINTER(c_int)], 'ARB_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:451
wglGetPbufferDCARB = _link_function('wglGetPbufferDCARB', HDC, [HPBUFFERARB], 'ARB_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:452
wglReleasePbufferDCARB = _link_function('wglReleasePbufferDCARB', c_int, [HPBUFFERARB, HDC], 'ARB_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:453
wglDestroyPbufferARB = _link_function('wglDestroyPbufferARB', BOOL, [HPBUFFERARB], 'ARB_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:454
wglQueryPbufferARB = _link_function('wglQueryPbufferARB', BOOL, [HPBUFFERARB, c_int, POINTER(c_int)], 'ARB_pbuffer')
PFNWGLCREATEPBUFFERARBPROC = CFUNCTYPE(HPBUFFERARB, HDC, c_int, c_int, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:456
PFNWGLGETPBUFFERDCARBPROC = CFUNCTYPE(HDC, HPBUFFERARB) # http://www.opengl.org/registry/api/wglext.h:457
PFNWGLRELEASEPBUFFERDCARBPROC = CFUNCTYPE(c_int, HPBUFFERARB, HDC) # http://www.opengl.org/registry/api/wglext.h:458
PFNWGLDESTROYPBUFFERARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB) # http://www.opengl.org/registry/api/wglext.h:459
PFNWGLQUERYPBUFFERARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:460
# ARB_render_texture (http://www.opengl.org/registry/api/wglext.h:463)
WGL_ARB_render_texture = 1 # http://www.opengl.org/registry/api/wglext.h:464
# http://www.opengl.org/registry/api/wglext.h:466
wglBindTexImageARB = _link_function('wglBindTexImageARB', BOOL, [HPBUFFERARB, c_int], 'ARB_render_texture')
# http://www.opengl.org/registry/api/wglext.h:467
wglReleaseTexImageARB = _link_function('wglReleaseTexImageARB', BOOL, [HPBUFFERARB, c_int], 'ARB_render_texture')
# http://www.opengl.org/registry/api/wglext.h:468
wglSetPbufferAttribARB = _link_function('wglSetPbufferAttribARB', BOOL, [HPBUFFERARB, POINTER(c_int)], 'ARB_render_texture')
PFNWGLBINDTEXIMAGEARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int) # http://www.opengl.org/registry/api/wglext.h:470
PFNWGLRELEASETEXIMAGEARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int) # http://www.opengl.org/registry/api/wglext.h:471
PFNWGLSETPBUFFERATTRIBARBPROC = CFUNCTYPE(BOOL, HPBUFFERARB, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:472
# ARB_pixel_format_float (http://www.opengl.org/registry/api/wglext.h:475)
WGL_ARB_pixel_format_float = 1 # http://www.opengl.org/registry/api/wglext.h:476
# ARB_create_context (http://www.opengl.org/registry/api/wglext.h:479)
WGL_ARB_create_context = 1 # http://www.opengl.org/registry/api/wglext.h:480
# http://www.opengl.org/registry/api/wglext.h:482
wglCreateContextAttribsARB = _link_function('wglCreateContextAttribsARB', HGLRC, [HDC, HGLRC, POINTER(c_int)], 'ARB_create_context')
PFNWGLCREATECONTEXTATTRIBSARBPROC = CFUNCTYPE(HGLRC, HDC, HGLRC, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:484
# EXT_display_color_table (http://www.opengl.org/registry/api/wglext.h:487)
WGL_EXT_display_color_table = 1 # http://www.opengl.org/registry/api/wglext.h:488
GLboolean = c_ubyte # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:18
GLushort = c_ushort # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:25
# http://www.opengl.org/registry/api/wglext.h:490
wglCreateDisplayColorTableEXT = _link_function('wglCreateDisplayColorTableEXT', GLboolean, [GLushort], 'EXT_display_color_table')
GLuint = c_uint # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:26
# http://www.opengl.org/registry/api/wglext.h:491
wglLoadDisplayColorTableEXT = _link_function('wglLoadDisplayColorTableEXT', GLboolean, [POINTER(GLushort), GLuint], 'EXT_display_color_table')
# http://www.opengl.org/registry/api/wglext.h:492
wglBindDisplayColorTableEXT = _link_function('wglBindDisplayColorTableEXT', GLboolean, [GLushort], 'EXT_display_color_table')
# http://www.opengl.org/registry/api/wglext.h:493
wglDestroyDisplayColorTableEXT = _link_function('wglDestroyDisplayColorTableEXT', VOID, [GLushort], 'EXT_display_color_table')
PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, GLushort) # http://www.opengl.org/registry/api/wglext.h:495
PFNWGLLOADDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, POINTER(GLushort), GLuint) # http://www.opengl.org/registry/api/wglext.h:496
PFNWGLBINDDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(GLboolean, GLushort) # http://www.opengl.org/registry/api/wglext.h:497
PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC = CFUNCTYPE(VOID, GLushort) # http://www.opengl.org/registry/api/wglext.h:498
# EXT_extensions_string (http://www.opengl.org/registry/api/wglext.h:501)
WGL_EXT_extensions_string = 1 # http://www.opengl.org/registry/api/wglext.h:502
# http://www.opengl.org/registry/api/wglext.h:504
wglGetExtensionsStringEXT = _link_function('wglGetExtensionsStringEXT', c_char_p, [], 'EXT_extensions_string')
PFNWGLGETEXTENSIONSSTRINGEXTPROC = CFUNCTYPE(c_char_p) # http://www.opengl.org/registry/api/wglext.h:506
# EXT_make_current_read (http://www.opengl.org/registry/api/wglext.h:509)
WGL_EXT_make_current_read = 1 # http://www.opengl.org/registry/api/wglext.h:510
# http://www.opengl.org/registry/api/wglext.h:512
wglMakeContextCurrentEXT = _link_function('wglMakeContextCurrentEXT', BOOL, [HDC, HDC, HGLRC], 'EXT_make_current_read')
# http://www.opengl.org/registry/api/wglext.h:513
wglGetCurrentReadDCEXT = _link_function('wglGetCurrentReadDCEXT', HDC, [], 'EXT_make_current_read')
PFNWGLMAKECONTEXTCURRENTEXTPROC = CFUNCTYPE(BOOL, HDC, HDC, HGLRC) # http://www.opengl.org/registry/api/wglext.h:515
PFNWGLGETCURRENTREADDCEXTPROC = CFUNCTYPE(HDC) # http://www.opengl.org/registry/api/wglext.h:516
# EXT_pbuffer (http://www.opengl.org/registry/api/wglext.h:519)
WGL_EXT_pbuffer = 1 # http://www.opengl.org/registry/api/wglext.h:520
# http://www.opengl.org/registry/api/wglext.h:522
wglCreatePbufferEXT = _link_function('wglCreatePbufferEXT', HPBUFFEREXT, [HDC, c_int, c_int, c_int, POINTER(c_int)], 'EXT_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:523
wglGetPbufferDCEXT = _link_function('wglGetPbufferDCEXT', HDC, [HPBUFFEREXT], 'EXT_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:524
wglReleasePbufferDCEXT = _link_function('wglReleasePbufferDCEXT', c_int, [HPBUFFEREXT, HDC], 'EXT_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:525
wglDestroyPbufferEXT = _link_function('wglDestroyPbufferEXT', BOOL, [HPBUFFEREXT], 'EXT_pbuffer')
# http://www.opengl.org/registry/api/wglext.h:526
wglQueryPbufferEXT = _link_function('wglQueryPbufferEXT', BOOL, [HPBUFFEREXT, c_int, POINTER(c_int)], 'EXT_pbuffer')
PFNWGLCREATEPBUFFEREXTPROC = CFUNCTYPE(HPBUFFEREXT, HDC, c_int, c_int, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:528
PFNWGLGETPBUFFERDCEXTPROC = CFUNCTYPE(HDC, HPBUFFEREXT) # http://www.opengl.org/registry/api/wglext.h:529
PFNWGLRELEASEPBUFFERDCEXTPROC = CFUNCTYPE(c_int, HPBUFFEREXT, HDC) # http://www.opengl.org/registry/api/wglext.h:530
PFNWGLDESTROYPBUFFEREXTPROC = CFUNCTYPE(BOOL, HPBUFFEREXT) # http://www.opengl.org/registry/api/wglext.h:531
PFNWGLQUERYPBUFFEREXTPROC = CFUNCTYPE(BOOL, HPBUFFEREXT, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:532
# EXT_pixel_format (http://www.opengl.org/registry/api/wglext.h:535)
WGL_EXT_pixel_format = 1 # http://www.opengl.org/registry/api/wglext.h:536
# http://www.opengl.org/registry/api/wglext.h:538
wglGetPixelFormatAttribivEXT = _link_function('wglGetPixelFormatAttribivEXT', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)], 'EXT_pixel_format')
# http://www.opengl.org/registry/api/wglext.h:539
wglGetPixelFormatAttribfvEXT = _link_function('wglGetPixelFormatAttribfvEXT', BOOL, [HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)], 'EXT_pixel_format')
# http://www.opengl.org/registry/api/wglext.h:540
wglChoosePixelFormatEXT = _link_function('wglChoosePixelFormatEXT', BOOL, [HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)], 'EXT_pixel_format')
PFNWGLGETPIXELFORMATATTRIBIVEXTPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:542
PFNWGLGETPIXELFORMATATTRIBFVEXTPROC = CFUNCTYPE(BOOL, HDC, c_int, c_int, UINT, POINTER(c_int), POINTER(FLOAT)) # http://www.opengl.org/registry/api/wglext.h:543
PFNWGLCHOOSEPIXELFORMATEXTPROC = CFUNCTYPE(BOOL, HDC, POINTER(c_int), POINTER(FLOAT), UINT, POINTER(c_int), POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:544
# EXT_swap_control (http://www.opengl.org/registry/api/wglext.h:547)
WGL_EXT_swap_control = 1 # http://www.opengl.org/registry/api/wglext.h:548
# http://www.opengl.org/registry/api/wglext.h:550
wglSwapIntervalEXT = _link_function('wglSwapIntervalEXT', BOOL, [c_int], 'EXT_swap_control')
# http://www.opengl.org/registry/api/wglext.h:551
wglGetSwapIntervalEXT = _link_function('wglGetSwapIntervalEXT', c_int, [], 'EXT_swap_control')
PFNWGLSWAPINTERVALEXTPROC = CFUNCTYPE(BOOL, c_int) # http://www.opengl.org/registry/api/wglext.h:553
PFNWGLGETSWAPINTERVALEXTPROC = CFUNCTYPE(c_int) # http://www.opengl.org/registry/api/wglext.h:554
# EXT_depth_float (http://www.opengl.org/registry/api/wglext.h:557)
WGL_EXT_depth_float = 1 # http://www.opengl.org/registry/api/wglext.h:558
# NV_vertex_array_range (http://www.opengl.org/registry/api/wglext.h:561)
WGL_NV_vertex_array_range = 1 # http://www.opengl.org/registry/api/wglext.h:562
GLsizei = c_int # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:23
GLfloat = c_float # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:27
# http://www.opengl.org/registry/api/wglext.h:564
wglAllocateMemoryNV = _link_function('wglAllocateMemoryNV', POINTER(c_void), [GLsizei, GLfloat, GLfloat, GLfloat], 'NV_vertex_array_range')
# http://www.opengl.org/registry/api/wglext.h:565
wglFreeMemoryNV = _link_function('wglFreeMemoryNV', None, [POINTER(None)], 'NV_vertex_array_range')
PFNWGLALLOCATEMEMORYNVPROC = CFUNCTYPE(POINTER(c_void), GLsizei, GLfloat, GLfloat, GLfloat) # http://www.opengl.org/registry/api/wglext.h:567
PFNWGLFREEMEMORYNVPROC = CFUNCTYPE(None, POINTER(None)) # http://www.opengl.org/registry/api/wglext.h:568
# 3DFX_multisample (http://www.opengl.org/registry/api/wglext.h:571)
WGL_3DFX_multisample = 1 # http://www.opengl.org/registry/api/wglext.h:572
# EXT_multisample (http://www.opengl.org/registry/api/wglext.h:575)
WGL_EXT_multisample = 1 # http://www.opengl.org/registry/api/wglext.h:576
# OML_sync_control (http://www.opengl.org/registry/api/wglext.h:579)
WGL_OML_sync_control = 1 # http://www.opengl.org/registry/api/wglext.h:580
INT64 = c_longlong # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:42
# http://www.opengl.org/registry/api/wglext.h:582
wglGetSyncValuesOML = _link_function('wglGetSyncValuesOML', BOOL, [HDC, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
INT32 = c_int # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:35
# http://www.opengl.org/registry/api/wglext.h:583
wglGetMscRateOML = _link_function('wglGetMscRateOML', BOOL, [HDC, POINTER(INT32), POINTER(INT32)], 'OML_sync_control')
# http://www.opengl.org/registry/api/wglext.h:584
wglSwapBuffersMscOML = _link_function('wglSwapBuffersMscOML', INT64, [HDC, INT64, INT64, INT64], 'OML_sync_control')
# http://www.opengl.org/registry/api/wglext.h:585
wglSwapLayerBuffersMscOML = _link_function('wglSwapLayerBuffersMscOML', INT64, [HDC, c_int, INT64, INT64, INT64], 'OML_sync_control')
# http://www.opengl.org/registry/api/wglext.h:586
wglWaitForMscOML = _link_function('wglWaitForMscOML', BOOL, [HDC, INT64, INT64, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
# http://www.opengl.org/registry/api/wglext.h:587
wglWaitForSbcOML = _link_function('wglWaitForSbcOML', BOOL, [HDC, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)], 'OML_sync_control')
PFNWGLGETSYNCVALUESOMLPROC = CFUNCTYPE(BOOL, HDC, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://www.opengl.org/registry/api/wglext.h:589
PFNWGLGETMSCRATEOMLPROC = CFUNCTYPE(BOOL, HDC, POINTER(INT32), POINTER(INT32)) # http://www.opengl.org/registry/api/wglext.h:590
PFNWGLSWAPBUFFERSMSCOMLPROC = CFUNCTYPE(INT64, HDC, INT64, INT64, INT64) # http://www.opengl.org/registry/api/wglext.h:591
PFNWGLSWAPLAYERBUFFERSMSCOMLPROC = CFUNCTYPE(INT64, HDC, c_int, INT64, INT64, INT64) # http://www.opengl.org/registry/api/wglext.h:592
PFNWGLWAITFORMSCOMLPROC = CFUNCTYPE(BOOL, HDC, INT64, INT64, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://www.opengl.org/registry/api/wglext.h:593
PFNWGLWAITFORSBCOMLPROC = CFUNCTYPE(BOOL, HDC, INT64, POINTER(INT64), POINTER(INT64), POINTER(INT64)) # http://www.opengl.org/registry/api/wglext.h:594
# I3D_digital_video_control (http://www.opengl.org/registry/api/wglext.h:597)
WGL_I3D_digital_video_control = 1 # http://www.opengl.org/registry/api/wglext.h:598
# http://www.opengl.org/registry/api/wglext.h:600
wglGetDigitalVideoParametersI3D = _link_function('wglGetDigitalVideoParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_digital_video_control')
# http://www.opengl.org/registry/api/wglext.h:601
wglSetDigitalVideoParametersI3D = _link_function('wglSetDigitalVideoParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_digital_video_control')
PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:603
PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:604
# I3D_gamma (http://www.opengl.org/registry/api/wglext.h:607)
WGL_I3D_gamma = 1 # http://www.opengl.org/registry/api/wglext.h:608
# http://www.opengl.org/registry/api/wglext.h:610
wglGetGammaTableParametersI3D = _link_function('wglGetGammaTableParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_gamma')
# http://www.opengl.org/registry/api/wglext.h:611
wglSetGammaTableParametersI3D = _link_function('wglSetGammaTableParametersI3D', BOOL, [HDC, c_int, POINTER(c_int)], 'I3D_gamma')
USHORT = c_ushort # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:49
# http://www.opengl.org/registry/api/wglext.h:612
wglGetGammaTableI3D = _link_function('wglGetGammaTableI3D', BOOL, [HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)], 'I3D_gamma')
# http://www.opengl.org/registry/api/wglext.h:613
wglSetGammaTableI3D = _link_function('wglSetGammaTableI3D', BOOL, [HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)], 'I3D_gamma')
PFNWGLGETGAMMATABLEPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:615
PFNWGLSETGAMMATABLEPARAMETERSI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:616
PFNWGLGETGAMMATABLEI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)) # http://www.opengl.org/registry/api/wglext.h:617
PFNWGLSETGAMMATABLEI3DPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(USHORT), POINTER(USHORT), POINTER(USHORT)) # http://www.opengl.org/registry/api/wglext.h:618
# I3D_genlock (http://www.opengl.org/registry/api/wglext.h:621)
WGL_I3D_genlock = 1 # http://www.opengl.org/registry/api/wglext.h:622
# http://www.opengl.org/registry/api/wglext.h:624
wglEnableGenlockI3D = _link_function('wglEnableGenlockI3D', BOOL, [HDC], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:625
wglDisableGenlockI3D = _link_function('wglDisableGenlockI3D', BOOL, [HDC], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:626
wglIsEnabledGenlockI3D = _link_function('wglIsEnabledGenlockI3D', BOOL, [HDC, POINTER(BOOL)], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:627
wglGenlockSourceI3D = _link_function('wglGenlockSourceI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:628
wglGetGenlockSourceI3D = _link_function('wglGetGenlockSourceI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:629
wglGenlockSourceEdgeI3D = _link_function('wglGenlockSourceEdgeI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:630
wglGetGenlockSourceEdgeI3D = _link_function('wglGetGenlockSourceEdgeI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:631
wglGenlockSampleRateI3D = _link_function('wglGenlockSampleRateI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:632
wglGetGenlockSampleRateI3D = _link_function('wglGetGenlockSampleRateI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:633
wglGenlockSourceDelayI3D = _link_function('wglGenlockSourceDelayI3D', BOOL, [HDC, UINT], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:634
wglGetGenlockSourceDelayI3D = _link_function('wglGetGenlockSourceDelayI3D', BOOL, [HDC, POINTER(UINT)], 'I3D_genlock')
# http://www.opengl.org/registry/api/wglext.h:635
wglQueryGenlockMaxSourceDelayI3D = _link_function('wglQueryGenlockMaxSourceDelayI3D', BOOL, [HDC, POINTER(UINT), POINTER(UINT)], 'I3D_genlock')
PFNWGLENABLEGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC) # http://www.opengl.org/registry/api/wglext.h:637
PFNWGLDISABLEGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC) # http://www.opengl.org/registry/api/wglext.h:638
PFNWGLISENABLEDGENLOCKI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(BOOL)) # http://www.opengl.org/registry/api/wglext.h:639
PFNWGLGENLOCKSOURCEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://www.opengl.org/registry/api/wglext.h:640
PFNWGLGETGENLOCKSOURCEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:641
PFNWGLGENLOCKSOURCEEDGEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://www.opengl.org/registry/api/wglext.h:642
PFNWGLGETGENLOCKSOURCEEDGEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:643
PFNWGLGENLOCKSAMPLERATEI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://www.opengl.org/registry/api/wglext.h:644
PFNWGLGETGENLOCKSAMPLERATEI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:645
PFNWGLGENLOCKSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, UINT) # http://www.opengl.org/registry/api/wglext.h:646
PFNWGLGETGENLOCKSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:647
PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(UINT), POINTER(UINT)) # http://www.opengl.org/registry/api/wglext.h:648
# I3D_image_buffer (http://www.opengl.org/registry/api/wglext.h:651)
WGL_I3D_image_buffer = 1 # http://www.opengl.org/registry/api/wglext.h:652
LPVOID = POINTER(None) # C:\cygwin\home\alex\projects\pyglet\tools\wgl.h:45
# http://www.opengl.org/registry/api/wglext.h:654
wglCreateImageBufferI3D = _link_function('wglCreateImageBufferI3D', LPVOID, [HDC, DWORD, UINT], 'I3D_image_buffer')
# http://www.opengl.org/registry/api/wglext.h:655
wglDestroyImageBufferI3D = _link_function('wglDestroyImageBufferI3D', BOOL, [HDC, LPVOID], 'I3D_image_buffer')
# http://www.opengl.org/registry/api/wglext.h:656
wglAssociateImageBufferEventsI3D = _link_function('wglAssociateImageBufferEventsI3D', BOOL, [HDC, POINTER(HANDLE), POINTER(LPVOID), POINTER(DWORD), UINT], 'I3D_image_buffer')
# http://www.opengl.org/registry/api/wglext.h:657
wglReleaseImageBufferEventsI3D = _link_function('wglReleaseImageBufferEventsI3D', BOOL, [HDC, POINTER(LPVOID), UINT], 'I3D_image_buffer')
PFNWGLCREATEIMAGEBUFFERI3DPROC = CFUNCTYPE(LPVOID, HDC, DWORD, UINT) # http://www.opengl.org/registry/api/wglext.h:659
PFNWGLDESTROYIMAGEBUFFERI3DPROC = CFUNCTYPE(BOOL, HDC, LPVOID) # http://www.opengl.org/registry/api/wglext.h:660
PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(HANDLE), POINTER(LPVOID), POINTER(DWORD), UINT) # http://www.opengl.org/registry/api/wglext.h:661
PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC = CFUNCTYPE(BOOL, HDC, POINTER(LPVOID), UINT) # http://www.opengl.org/registry/api/wglext.h:662
# I3D_swap_frame_lock (http://www.opengl.org/registry/api/wglext.h:665)
WGL_I3D_swap_frame_lock = 1 # http://www.opengl.org/registry/api/wglext.h:666
# http://www.opengl.org/registry/api/wglext.h:668
wglEnableFrameLockI3D = _link_function('wglEnableFrameLockI3D', BOOL, [], 'I3D_swap_frame_lock')
# http://www.opengl.org/registry/api/wglext.h:669
wglDisableFrameLockI3D = _link_function('wglDisableFrameLockI3D', BOOL, [], 'I3D_swap_frame_lock')
# http://www.opengl.org/registry/api/wglext.h:670
wglIsEnabledFrameLockI3D = _link_function('wglIsEnabledFrameLockI3D', BOOL, [POINTER(BOOL)], 'I3D_swap_frame_lock')
# http://www.opengl.org/registry/api/wglext.h:671
wglQueryFrameLockMasterI3D = _link_function('wglQueryFrameLockMasterI3D', BOOL, [POINTER(BOOL)], 'I3D_swap_frame_lock')
PFNWGLENABLEFRAMELOCKI3DPROC = CFUNCTYPE(BOOL) # http://www.opengl.org/registry/api/wglext.h:673
PFNWGLDISABLEFRAMELOCKI3DPROC = CFUNCTYPE(BOOL) # http://www.opengl.org/registry/api/wglext.h:674
PFNWGLISENABLEDFRAMELOCKI3DPROC = CFUNCTYPE(BOOL, POINTER(BOOL)) # http://www.opengl.org/registry/api/wglext.h:675
PFNWGLQUERYFRAMELOCKMASTERI3DPROC = CFUNCTYPE(BOOL, POINTER(BOOL)) # http://www.opengl.org/registry/api/wglext.h:676
# I3D_swap_frame_usage (http://www.opengl.org/registry/api/wglext.h:679)
WGL_I3D_swap_frame_usage = 1 # http://www.opengl.org/registry/api/wglext.h:680
# http://www.opengl.org/registry/api/wglext.h:682
wglGetFrameUsageI3D = _link_function('wglGetFrameUsageI3D', BOOL, [POINTER(c_float)], 'I3D_swap_frame_usage')
# http://www.opengl.org/registry/api/wglext.h:683
wglBeginFrameTrackingI3D = _link_function('wglBeginFrameTrackingI3D', BOOL, [], 'I3D_swap_frame_usage')
# http://www.opengl.org/registry/api/wglext.h:684
wglEndFrameTrackingI3D = _link_function('wglEndFrameTrackingI3D', BOOL, [], 'I3D_swap_frame_usage')
# http://www.opengl.org/registry/api/wglext.h:685
wglQueryFrameTrackingI3D = _link_function('wglQueryFrameTrackingI3D', BOOL, [POINTER(DWORD), POINTER(DWORD), POINTER(c_float)], 'I3D_swap_frame_usage')
PFNWGLGETFRAMEUSAGEI3DPROC = CFUNCTYPE(BOOL, POINTER(c_float)) # http://www.opengl.org/registry/api/wglext.h:687
PFNWGLBEGINFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL) # http://www.opengl.org/registry/api/wglext.h:688
PFNWGLENDFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL) # http://www.opengl.org/registry/api/wglext.h:689
PFNWGLQUERYFRAMETRACKINGI3DPROC = CFUNCTYPE(BOOL, POINTER(DWORD), POINTER(DWORD), POINTER(c_float)) # http://www.opengl.org/registry/api/wglext.h:690
# ATI_pixel_format_float (http://www.opengl.org/registry/api/wglext.h:693)
WGL_ATI_pixel_format_float = 1 # http://www.opengl.org/registry/api/wglext.h:694
# NV_float_buffer (http://www.opengl.org/registry/api/wglext.h:697)
WGL_NV_float_buffer = 1 # http://www.opengl.org/registry/api/wglext.h:698
# EXT_pixel_format_packed_float (http://www.opengl.org/registry/api/wglext.h:701)
WGL_EXT_pixel_format_packed_float = 1 # http://www.opengl.org/registry/api/wglext.h:702
# EXT_framebuffer_sRGB (http://www.opengl.org/registry/api/wglext.h:705)
WGL_EXT_framebuffer_sRGB = 1 # http://www.opengl.org/registry/api/wglext.h:706
# NV_present_video (http://www.opengl.org/registry/api/wglext.h:709)
WGL_NV_present_video = 1 # http://www.opengl.org/registry/api/wglext.h:710
# http://www.opengl.org/registry/api/wglext.h:712
wglEnumerateVideoDevicesNV = _link_function('wglEnumerateVideoDevicesNV', c_int, [HDC, POINTER(HVIDEOOUTPUTDEVICENV)], 'NV_present_video')
# http://www.opengl.org/registry/api/wglext.h:713
wglBindVideoDeviceNV = _link_function('wglBindVideoDeviceNV', BOOL, [HDC, c_uint, HVIDEOOUTPUTDEVICENV, POINTER(c_int)], 'NV_present_video')
# http://www.opengl.org/registry/api/wglext.h:714
wglQueryCurrentContextNV = _link_function('wglQueryCurrentContextNV', BOOL, [c_int, POINTER(c_int)], 'NV_present_video')
PFNWGLENUMERATEVIDEODEVICESNVPROC = CFUNCTYPE(c_int, HDC, POINTER(HVIDEOOUTPUTDEVICENV)) # http://www.opengl.org/registry/api/wglext.h:716
PFNWGLBINDVIDEODEVICENVPROC = CFUNCTYPE(BOOL, HDC, c_uint, HVIDEOOUTPUTDEVICENV, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:717
PFNWGLQUERYCURRENTCONTEXTNVPROC = CFUNCTYPE(BOOL, c_int, POINTER(c_int)) # http://www.opengl.org/registry/api/wglext.h:718
# NV_video_out (http://www.opengl.org/registry/api/wglext.h:721)
WGL_NV_video_out = 1 # http://www.opengl.org/registry/api/wglext.h:722
# http://www.opengl.org/registry/api/wglext.h:724
wglGetVideoDeviceNV = _link_function('wglGetVideoDeviceNV', BOOL, [HDC, c_int, POINTER(HPVIDEODEV)], 'NV_video_out')
# http://www.opengl.org/registry/api/wglext.h:725
wglReleaseVideoDeviceNV = _link_function('wglReleaseVideoDeviceNV', BOOL, [HPVIDEODEV], 'NV_video_out')
# http://www.opengl.org/registry/api/wglext.h:726
wglBindVideoImageNV = _link_function('wglBindVideoImageNV', BOOL, [HPVIDEODEV, HPBUFFERARB, c_int], 'NV_video_out')
# http://www.opengl.org/registry/api/wglext.h:727
wglReleaseVideoImageNV = _link_function('wglReleaseVideoImageNV', BOOL, [HPBUFFERARB, c_int], 'NV_video_out')
# http://www.opengl.org/registry/api/wglext.h:728
wglSendPbufferToVideoNV = _link_function('wglSendPbufferToVideoNV', BOOL, [HPBUFFERARB, c_int, POINTER(c_ulong), BOOL], 'NV_video_out')
# http://www.opengl.org/registry/api/wglext.h:729
wglGetVideoInfoNV = _link_function('wglGetVideoInfoNV', BOOL, [HPVIDEODEV, POINTER(c_ulong), POINTER(c_ulong)], 'NV_video_out')
PFNWGLGETVIDEODEVICENVPROC = CFUNCTYPE(BOOL, HDC, c_int, POINTER(HPVIDEODEV)) # http://www.opengl.org/registry/api/wglext.h:731
PFNWGLRELEASEVIDEODEVICENVPROC = CFUNCTYPE(BOOL, HPVIDEODEV) # http://www.opengl.org/registry/api/wglext.h:732
PFNWGLBINDVIDEOIMAGENVPROC = CFUNCTYPE(BOOL, HPVIDEODEV, HPBUFFERARB, c_int) # http://www.opengl.org/registry/api/wglext.h:733
PFNWGLRELEASEVIDEOIMAGENVPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int) # http://www.opengl.org/registry/api/wglext.h:734
PFNWGLSENDPBUFFERTOVIDEONVPROC = CFUNCTYPE(BOOL, HPBUFFERARB, c_int, POINTER(c_ulong), BOOL) # http://www.opengl.org/registry/api/wglext.h:735
PFNWGLGETVIDEOINFONVPROC = CFUNCTYPE(BOOL, HPVIDEODEV, POINTER(c_ulong), POINTER(c_ulong)) # http://www.opengl.org/registry/api/wglext.h:736
# NV_swap_group (http://www.opengl.org/registry/api/wglext.h:739)
WGL_NV_swap_group = 1 # http://www.opengl.org/registry/api/wglext.h:740
# http://www.opengl.org/registry/api/wglext.h:742
wglJoinSwapGroupNV = _link_function('wglJoinSwapGroupNV', BOOL, [HDC, GLuint], 'NV_swap_group')
# http://www.opengl.org/registry/api/wglext.h:743
wglBindSwapBarrierNV = _link_function('wglBindSwapBarrierNV', BOOL, [GLuint, GLuint], 'NV_swap_group')
# http://www.opengl.org/registry/api/wglext.h:744
wglQuerySwapGroupNV = _link_function('wglQuerySwapGroupNV', BOOL, [HDC, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# http://www.opengl.org/registry/api/wglext.h:745
wglQueryMaxSwapGroupsNV = _link_function('wglQueryMaxSwapGroupsNV', BOOL, [HDC, POINTER(GLuint), POINTER(GLuint)], 'NV_swap_group')
# http://www.opengl.org/registry/api/wglext.h:746
wglQueryFrameCountNV = _link_function('wglQueryFrameCountNV', BOOL, [HDC, POINTER(GLuint)], 'NV_swap_group')
# http://www.opengl.org/registry/api/wglext.h:747
wglResetFrameCountNV = _link_function('wglResetFrameCountNV', BOOL, [HDC], 'NV_swap_group')
PFNWGLJOINSWAPGROUPNVPROC = CFUNCTYPE(BOOL, HDC, GLuint) # http://www.opengl.org/registry/api/wglext.h:749
PFNWGLBINDSWAPBARRIERNVPROC = CFUNCTYPE(BOOL, GLuint, GLuint) # http://www.opengl.org/registry/api/wglext.h:750
PFNWGLQUERYSWAPGROUPNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint), POINTER(GLuint)) # http://www.opengl.org/registry/api/wglext.h:751
PFNWGLQUERYMAXSWAPGROUPSNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint), POINTER(GLuint)) # http://www.opengl.org/registry/api/wglext.h:752
PFNWGLQUERYFRAMECOUNTNVPROC = CFUNCTYPE(BOOL, HDC, POINTER(GLuint)) # http://www.opengl.org/registry/api/wglext.h:753
PFNWGLRESETFRAMECOUNTNVPROC = CFUNCTYPE(BOOL, HDC) # http://www.opengl.org/registry/api/wglext.h:754
# NV_gpu_affinity (http://www.opengl.org/registry/api/wglext.h:757)
WGL_NV_gpu_affinity = 1 # http://www.opengl.org/registry/api/wglext.h:758
# http://www.opengl.org/registry/api/wglext.h:760
wglEnumGpusNV = _link_function('wglEnumGpusNV', BOOL, [UINT, POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://www.opengl.org/registry/api/wglext.h:761
wglEnumGpuDevicesNV = _link_function('wglEnumGpuDevicesNV', BOOL, [HGPUNV, UINT, PGPU_DEVICE], 'NV_gpu_affinity')
# http://www.opengl.org/registry/api/wglext.h:762
wglCreateAffinityDCNV = _link_function('wglCreateAffinityDCNV', HDC, [POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://www.opengl.org/registry/api/wglext.h:763
wglEnumGpusFromAffinityDCNV = _link_function('wglEnumGpusFromAffinityDCNV', BOOL, [HDC, UINT, POINTER(HGPUNV)], 'NV_gpu_affinity')
# http://www.opengl.org/registry/api/wglext.h:764
wglDeleteDCNV = _link_function('wglDeleteDCNV', BOOL, [HDC], 'NV_gpu_affinity')
PFNWGLENUMGPUSNVPROC = CFUNCTYPE(BOOL, UINT, POINTER(HGPUNV)) # http://www.opengl.org/registry/api/wglext.h:766
PFNWGLENUMGPUDEVICESNVPROC = CFUNCTYPE(BOOL, HGPUNV, UINT, PGPU_DEVICE) # http://www.opengl.org/registry/api/wglext.h:767
PFNWGLCREATEAFFINITYDCNVPROC = CFUNCTYPE(HDC, POINTER(HGPUNV)) # http://www.opengl.org/registry/api/wglext.h:768
PFNWGLENUMGPUSFROMAFFINITYDCNVPROC = CFUNCTYPE(BOOL, HDC, UINT, POINTER(HGPUNV)) # http://www.opengl.org/registry/api/wglext.h:769
PFNWGLDELETEDCNVPROC = CFUNCTYPE(BOOL, HDC) # http://www.opengl.org/registry/api/wglext.h:770
__all__ = ['WIN32_LEAN_AND_MEAN', 'WGL_WGLEXT_VERSION',
'WGL_FRONT_COLOR_BUFFER_BIT_ARB', 'WGL_BACK_COLOR_BUFFER_BIT_ARB',
'WGL_DEPTH_BUFFER_BIT_ARB', 'WGL_STENCIL_BUFFER_BIT_ARB',
'WGL_SAMPLE_BUFFERS_ARB', 'WGL_SAMPLES_ARB', 'WGL_NUMBER_PIXEL_FORMATS_ARB',
'WGL_DRAW_TO_WINDOW_ARB', 'WGL_DRAW_TO_BITMAP_ARB', 'WGL_ACCELERATION_ARB',
'WGL_NEED_PALETTE_ARB', 'WGL_NEED_SYSTEM_PALETTE_ARB',
'WGL_SWAP_LAYER_BUFFERS_ARB', 'WGL_SWAP_METHOD_ARB',
'WGL_NUMBER_OVERLAYS_ARB', 'WGL_NUMBER_UNDERLAYS_ARB', 'WGL_TRANSPARENT_ARB',
'WGL_TRANSPARENT_RED_VALUE_ARB', 'WGL_TRANSPARENT_GREEN_VALUE_ARB',
'WGL_TRANSPARENT_BLUE_VALUE_ARB', 'WGL_TRANSPARENT_ALPHA_VALUE_ARB',
'WGL_TRANSPARENT_INDEX_VALUE_ARB', 'WGL_SHARE_DEPTH_ARB',
'WGL_SHARE_STENCIL_ARB', 'WGL_SHARE_ACCUM_ARB', 'WGL_SUPPORT_GDI_ARB',
'WGL_SUPPORT_OPENGL_ARB', 'WGL_DOUBLE_BUFFER_ARB', 'WGL_STEREO_ARB',
'WGL_PIXEL_TYPE_ARB', 'WGL_COLOR_BITS_ARB', 'WGL_RED_BITS_ARB',
'WGL_RED_SHIFT_ARB', 'WGL_GREEN_BITS_ARB', 'WGL_GREEN_SHIFT_ARB',
'WGL_BLUE_BITS_ARB', 'WGL_BLUE_SHIFT_ARB', 'WGL_ALPHA_BITS_ARB',
'WGL_ALPHA_SHIFT_ARB', 'WGL_ACCUM_BITS_ARB', 'WGL_ACCUM_RED_BITS_ARB',
'WGL_ACCUM_GREEN_BITS_ARB', 'WGL_ACCUM_BLUE_BITS_ARB',
'WGL_ACCUM_ALPHA_BITS_ARB', 'WGL_DEPTH_BITS_ARB', 'WGL_STENCIL_BITS_ARB',
'WGL_AUX_BUFFERS_ARB', 'WGL_NO_ACCELERATION_ARB',
'WGL_GENERIC_ACCELERATION_ARB', 'WGL_FULL_ACCELERATION_ARB',
'WGL_SWAP_EXCHANGE_ARB', 'WGL_SWAP_COPY_ARB', 'WGL_SWAP_UNDEFINED_ARB',
'WGL_TYPE_RGBA_ARB', 'WGL_TYPE_COLORINDEX_ARB',
'ERROR_INVALID_PIXEL_TYPE_ARB', 'ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB',
'WGL_DRAW_TO_PBUFFER_ARB', 'WGL_MAX_PBUFFER_PIXELS_ARB',
'WGL_MAX_PBUFFER_WIDTH_ARB', 'WGL_MAX_PBUFFER_HEIGHT_ARB',
'WGL_PBUFFER_LARGEST_ARB', 'WGL_PBUFFER_WIDTH_ARB', 'WGL_PBUFFER_HEIGHT_ARB',
'WGL_PBUFFER_LOST_ARB', 'WGL_BIND_TO_TEXTURE_RGB_ARB',
'WGL_BIND_TO_TEXTURE_RGBA_ARB', 'WGL_TEXTURE_FORMAT_ARB',
'WGL_TEXTURE_TARGET_ARB', 'WGL_MIPMAP_TEXTURE_ARB', 'WGL_TEXTURE_RGB_ARB',
'WGL_TEXTURE_RGBA_ARB', 'WGL_NO_TEXTURE_ARB', 'WGL_TEXTURE_CUBE_MAP_ARB',
'WGL_TEXTURE_1D_ARB', 'WGL_TEXTURE_2D_ARB', 'WGL_MIPMAP_LEVEL_ARB',
'WGL_CUBE_MAP_FACE_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB', 'WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB',
'WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB', 'WGL_FRONT_LEFT_ARB',
'WGL_FRONT_RIGHT_ARB', 'WGL_BACK_LEFT_ARB', 'WGL_BACK_RIGHT_ARB',
'WGL_AUX0_ARB', 'WGL_AUX1_ARB', 'WGL_AUX2_ARB', 'WGL_AUX3_ARB',
'WGL_AUX4_ARB', 'WGL_AUX5_ARB', 'WGL_AUX6_ARB', 'WGL_AUX7_ARB',
'WGL_AUX8_ARB', 'WGL_AUX9_ARB', 'WGL_TYPE_RGBA_FLOAT_ARB',
'WGL_CONTEXT_DEBUG_BIT_ARB', 'WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB',
'WGL_CONTEXT_MAJOR_VERSION_ARB', 'WGL_CONTEXT_MINOR_VERSION_ARB',
'WGL_CONTEXT_LAYER_PLANE_ARB', 'WGL_CONTEXT_FLAGS_ARB',
'ERROR_INVALID_VERSION_ARB', 'ERROR_INVALID_PIXEL_TYPE_EXT',
'WGL_NUMBER_PIXEL_FORMATS_EXT', 'WGL_DRAW_TO_WINDOW_EXT',
'WGL_DRAW_TO_BITMAP_EXT', 'WGL_ACCELERATION_EXT', 'WGL_NEED_PALETTE_EXT',
'WGL_NEED_SYSTEM_PALETTE_EXT', 'WGL_SWAP_LAYER_BUFFERS_EXT',
'WGL_SWAP_METHOD_EXT', 'WGL_NUMBER_OVERLAYS_EXT', 'WGL_NUMBER_UNDERLAYS_EXT',
'WGL_TRANSPARENT_EXT', 'WGL_TRANSPARENT_VALUE_EXT', 'WGL_SHARE_DEPTH_EXT',
'WGL_SHARE_STENCIL_EXT', 'WGL_SHARE_ACCUM_EXT', 'WGL_SUPPORT_GDI_EXT',
'WGL_SUPPORT_OPENGL_EXT', 'WGL_DOUBLE_BUFFER_EXT', 'WGL_STEREO_EXT',
'WGL_PIXEL_TYPE_EXT', 'WGL_COLOR_BITS_EXT', 'WGL_RED_BITS_EXT',
'WGL_RED_SHIFT_EXT', 'WGL_GREEN_BITS_EXT', 'WGL_GREEN_SHIFT_EXT',
'WGL_BLUE_BITS_EXT', 'WGL_BLUE_SHIFT_EXT', 'WGL_ALPHA_BITS_EXT',
'WGL_ALPHA_SHIFT_EXT', 'WGL_ACCUM_BITS_EXT', 'WGL_ACCUM_RED_BITS_EXT',
'WGL_ACCUM_GREEN_BITS_EXT', 'WGL_ACCUM_BLUE_BITS_EXT',
'WGL_ACCUM_ALPHA_BITS_EXT', 'WGL_DEPTH_BITS_EXT', 'WGL_STENCIL_BITS_EXT',
'WGL_AUX_BUFFERS_EXT', 'WGL_NO_ACCELERATION_EXT',
'WGL_GENERIC_ACCELERATION_EXT', 'WGL_FULL_ACCELERATION_EXT',
'WGL_SWAP_EXCHANGE_EXT', 'WGL_SWAP_COPY_EXT', 'WGL_SWAP_UNDEFINED_EXT',
'WGL_TYPE_RGBA_EXT', 'WGL_TYPE_COLORINDEX_EXT', 'WGL_DRAW_TO_PBUFFER_EXT',
'WGL_MAX_PBUFFER_PIXELS_EXT', 'WGL_MAX_PBUFFER_WIDTH_EXT',
'WGL_MAX_PBUFFER_HEIGHT_EXT', 'WGL_OPTIMAL_PBUFFER_WIDTH_EXT',
'WGL_OPTIMAL_PBUFFER_HEIGHT_EXT', 'WGL_PBUFFER_LARGEST_EXT',
'WGL_PBUFFER_WIDTH_EXT', 'WGL_PBUFFER_HEIGHT_EXT', 'WGL_DEPTH_FLOAT_EXT',
'WGL_SAMPLE_BUFFERS_3DFX', 'WGL_SAMPLES_3DFX', 'WGL_SAMPLE_BUFFERS_EXT',
'WGL_SAMPLES_EXT', 'WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D',
'WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D',
'WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D',
'WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D', 'WGL_GAMMA_TABLE_SIZE_I3D',
'WGL_GAMMA_EXCLUDE_DESKTOP_I3D', 'WGL_GENLOCK_SOURCE_MULTIVIEW_I3D',
'WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D', 'WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D',
'WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D', 'WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D',
'WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D', 'WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D',
'WGL_GENLOCK_SOURCE_EDGE_RISING_I3D', 'WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D',
'WGL_IMAGE_BUFFER_MIN_ACCESS_I3D', 'WGL_IMAGE_BUFFER_LOCK_I3D',
'WGL_BIND_TO_TEXTURE_DEPTH_NV', 'WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV',
'WGL_DEPTH_TEXTURE_FORMAT_NV', 'WGL_TEXTURE_DEPTH_COMPONENT_NV',
'WGL_DEPTH_COMPONENT_NV', 'WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV', 'WGL_TEXTURE_RECTANGLE_NV',
'WGL_TYPE_RGBA_FLOAT_ATI', 'WGL_FLOAT_COMPONENTS_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV',
'WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV', 'WGL_TEXTURE_FLOAT_R_NV',
'WGL_TEXTURE_FLOAT_RG_NV', 'WGL_TEXTURE_FLOAT_RGB_NV',
'WGL_TEXTURE_FLOAT_RGBA_NV', 'WGL_STEREO_EMITTER_ENABLE_3DL',
'WGL_STEREO_EMITTER_DISABLE_3DL', 'WGL_STEREO_POLARITY_NORMAL_3DL',
'WGL_STEREO_POLARITY_INVERT_3DL', 'WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT',
'WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT', 'WGL_NUM_VIDEO_SLOTS_NV',
'WGL_BIND_TO_VIDEO_RGB_NV', 'WGL_BIND_TO_VIDEO_RGBA_NV',
'WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV', 'WGL_VIDEO_OUT_COLOR_NV',
'WGL_VIDEO_OUT_ALPHA_NV', 'WGL_VIDEO_OUT_DEPTH_NV',
'WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV', 'WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV',
'WGL_VIDEO_OUT_FRAME', 'WGL_VIDEO_OUT_FIELD_1', 'WGL_VIDEO_OUT_FIELD_2',
'WGL_VIDEO_OUT_STACKED_FIELDS_1_2', 'WGL_VIDEO_OUT_STACKED_FIELDS_2_1',
'WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV',
'WGL_ERROR_MISSING_AFFINITY_MASK_NV', 'HPBUFFERARB', 'HPBUFFEREXT',
'HVIDEOOUTPUTDEVICENV', 'HPVIDEODEV', 'HPGPUNV', 'HGPUNV', 'GPU_DEVICE',
'PGPU_DEVICE', 'WGL_ARB_buffer_region', 'wglCreateBufferRegionARB',
'wglDeleteBufferRegionARB', 'wglSaveBufferRegionARB',
'wglRestoreBufferRegionARB', 'PFNWGLCREATEBUFFERREGIONARBPROC',
'PFNWGLDELETEBUFFERREGIONARBPROC', 'PFNWGLSAVEBUFFERREGIONARBPROC',
'PFNWGLRESTOREBUFFERREGIONARBPROC', 'WGL_ARB_multisample',
'WGL_ARB_extensions_string', 'wglGetExtensionsStringARB',
'PFNWGLGETEXTENSIONSSTRINGARBPROC', 'WGL_ARB_pixel_format',
'wglGetPixelFormatAttribivARB', 'wglGetPixelFormatAttribfvARB',
'wglChoosePixelFormatARB', 'PFNWGLGETPIXELFORMATATTRIBIVARBPROC',
'PFNWGLGETPIXELFORMATATTRIBFVARBPROC', 'PFNWGLCHOOSEPIXELFORMATARBPROC',
'WGL_ARB_make_current_read', 'wglMakeContextCurrentARB',
'wglGetCurrentReadDCARB', 'PFNWGLMAKECONTEXTCURRENTARBPROC',
'PFNWGLGETCURRENTREADDCARBPROC', 'WGL_ARB_pbuffer', 'wglCreatePbufferARB',
'wglGetPbufferDCARB', 'wglReleasePbufferDCARB', 'wglDestroyPbufferARB',
'wglQueryPbufferARB', 'PFNWGLCREATEPBUFFERARBPROC',
'PFNWGLGETPBUFFERDCARBPROC', 'PFNWGLRELEASEPBUFFERDCARBPROC',
'PFNWGLDESTROYPBUFFERARBPROC', 'PFNWGLQUERYPBUFFERARBPROC',
'WGL_ARB_render_texture', 'wglBindTexImageARB', 'wglReleaseTexImageARB',
'wglSetPbufferAttribARB', 'PFNWGLBINDTEXIMAGEARBPROC',
'PFNWGLRELEASETEXIMAGEARBPROC', 'PFNWGLSETPBUFFERATTRIBARBPROC',
'WGL_ARB_pixel_format_float', 'WGL_ARB_create_context',
'wglCreateContextAttribsARB', 'PFNWGLCREATECONTEXTATTRIBSARBPROC',
'WGL_EXT_display_color_table', 'wglCreateDisplayColorTableEXT',
'wglLoadDisplayColorTableEXT', 'wglBindDisplayColorTableEXT',
'wglDestroyDisplayColorTableEXT', 'PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC',
'PFNWGLLOADDISPLAYCOLORTABLEEXTPROC', 'PFNWGLBINDDISPLAYCOLORTABLEEXTPROC',
'PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC', 'WGL_EXT_extensions_string',
'wglGetExtensionsStringEXT', 'PFNWGLGETEXTENSIONSSTRINGEXTPROC',
'WGL_EXT_make_current_read', 'wglMakeContextCurrentEXT',
'wglGetCurrentReadDCEXT', 'PFNWGLMAKECONTEXTCURRENTEXTPROC',
'PFNWGLGETCURRENTREADDCEXTPROC', 'WGL_EXT_pbuffer', 'wglCreatePbufferEXT',
'wglGetPbufferDCEXT', 'wglReleasePbufferDCEXT', 'wglDestroyPbufferEXT',
'wglQueryPbufferEXT', 'PFNWGLCREATEPBUFFEREXTPROC',
'PFNWGLGETPBUFFERDCEXTPROC', 'PFNWGLRELEASEPBUFFERDCEXTPROC',
'PFNWGLDESTROYPBUFFEREXTPROC', 'PFNWGLQUERYPBUFFEREXTPROC',
'WGL_EXT_pixel_format', 'wglGetPixelFormatAttribivEXT',
'wglGetPixelFormatAttribfvEXT', 'wglChoosePixelFormatEXT',
'PFNWGLGETPIXELFORMATATTRIBIVEXTPROC', 'PFNWGLGETPIXELFORMATATTRIBFVEXTPROC',
'PFNWGLCHOOSEPIXELFORMATEXTPROC', 'WGL_EXT_swap_control',
'wglSwapIntervalEXT', 'wglGetSwapIntervalEXT', 'PFNWGLSWAPINTERVALEXTPROC',
'PFNWGLGETSWAPINTERVALEXTPROC', 'WGL_EXT_depth_float',
'WGL_NV_vertex_array_range', 'wglAllocateMemoryNV', 'wglFreeMemoryNV',
'PFNWGLALLOCATEMEMORYNVPROC', 'PFNWGLFREEMEMORYNVPROC',
'WGL_3DFX_multisample', 'WGL_EXT_multisample', 'WGL_OML_sync_control',
'wglGetSyncValuesOML', 'wglGetMscRateOML', 'wglSwapBuffersMscOML',
'wglSwapLayerBuffersMscOML', 'wglWaitForMscOML', 'wglWaitForSbcOML',
'PFNWGLGETSYNCVALUESOMLPROC', 'PFNWGLGETMSCRATEOMLPROC',
'PFNWGLSWAPBUFFERSMSCOMLPROC', 'PFNWGLSWAPLAYERBUFFERSMSCOMLPROC',
'PFNWGLWAITFORMSCOMLPROC', 'PFNWGLWAITFORSBCOMLPROC',
'WGL_I3D_digital_video_control', 'wglGetDigitalVideoParametersI3D',
'wglSetDigitalVideoParametersI3D', 'PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC',
'PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC', 'WGL_I3D_gamma',
'wglGetGammaTableParametersI3D', 'wglSetGammaTableParametersI3D',
'wglGetGammaTableI3D', 'wglSetGammaTableI3D',
'PFNWGLGETGAMMATABLEPARAMETERSI3DPROC',
'PFNWGLSETGAMMATABLEPARAMETERSI3DPROC', 'PFNWGLGETGAMMATABLEI3DPROC',
'PFNWGLSETGAMMATABLEI3DPROC', 'WGL_I3D_genlock', 'wglEnableGenlockI3D',
'wglDisableGenlockI3D', 'wglIsEnabledGenlockI3D', 'wglGenlockSourceI3D',
'wglGetGenlockSourceI3D', 'wglGenlockSourceEdgeI3D',
'wglGetGenlockSourceEdgeI3D', 'wglGenlockSampleRateI3D',
'wglGetGenlockSampleRateI3D', 'wglGenlockSourceDelayI3D',
'wglGetGenlockSourceDelayI3D', 'wglQueryGenlockMaxSourceDelayI3D',
'PFNWGLENABLEGENLOCKI3DPROC', 'PFNWGLDISABLEGENLOCKI3DPROC',
'PFNWGLISENABLEDGENLOCKI3DPROC', 'PFNWGLGENLOCKSOURCEI3DPROC',
'PFNWGLGETGENLOCKSOURCEI3DPROC', 'PFNWGLGENLOCKSOURCEEDGEI3DPROC',
'PFNWGLGETGENLOCKSOURCEEDGEI3DPROC', 'PFNWGLGENLOCKSAMPLERATEI3DPROC',
'PFNWGLGETGENLOCKSAMPLERATEI3DPROC', 'PFNWGLGENLOCKSOURCEDELAYI3DPROC',
'PFNWGLGETGENLOCKSOURCEDELAYI3DPROC',
'PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC', 'WGL_I3D_image_buffer',
'wglCreateImageBufferI3D', 'wglDestroyImageBufferI3D',
'wglAssociateImageBufferEventsI3D', 'wglReleaseImageBufferEventsI3D',
'PFNWGLCREATEIMAGEBUFFERI3DPROC', 'PFNWGLDESTROYIMAGEBUFFERI3DPROC',
'PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC',
'PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC', 'WGL_I3D_swap_frame_lock',
'wglEnableFrameLockI3D', 'wglDisableFrameLockI3D', 'wglIsEnabledFrameLockI3D',
'wglQueryFrameLockMasterI3D', 'PFNWGLENABLEFRAMELOCKI3DPROC',
'PFNWGLDISABLEFRAMELOCKI3DPROC', 'PFNWGLISENABLEDFRAMELOCKI3DPROC',
'PFNWGLQUERYFRAMELOCKMASTERI3DPROC', 'WGL_I3D_swap_frame_usage',
'wglGetFrameUsageI3D', 'wglBeginFrameTrackingI3D', 'wglEndFrameTrackingI3D',
'wglQueryFrameTrackingI3D', 'PFNWGLGETFRAMEUSAGEI3DPROC',
'PFNWGLBEGINFRAMETRACKINGI3DPROC', 'PFNWGLENDFRAMETRACKINGI3DPROC',
'PFNWGLQUERYFRAMETRACKINGI3DPROC', 'WGL_ATI_pixel_format_float',
'WGL_NV_float_buffer', 'WGL_EXT_pixel_format_packed_float',
'WGL_EXT_framebuffer_sRGB', 'WGL_NV_present_video',
'wglEnumerateVideoDevicesNV', 'wglBindVideoDeviceNV',
'wglQueryCurrentContextNV', 'PFNWGLENUMERATEVIDEODEVICESNVPROC',
'PFNWGLBINDVIDEODEVICENVPROC', 'PFNWGLQUERYCURRENTCONTEXTNVPROC',
'WGL_NV_video_out', 'wglGetVideoDeviceNV', 'wglReleaseVideoDeviceNV',
'wglBindVideoImageNV', 'wglReleaseVideoImageNV', 'wglSendPbufferToVideoNV',
'wglGetVideoInfoNV', 'PFNWGLGETVIDEODEVICENVPROC',
'PFNWGLRELEASEVIDEODEVICENVPROC', 'PFNWGLBINDVIDEOIMAGENVPROC',
'PFNWGLRELEASEVIDEOIMAGENVPROC', 'PFNWGLSENDPBUFFERTOVIDEONVPROC',
'PFNWGLGETVIDEOINFONVPROC', 'WGL_NV_swap_group', 'wglJoinSwapGroupNV',
'wglBindSwapBarrierNV', 'wglQuerySwapGroupNV', 'wglQueryMaxSwapGroupsNV',
'wglQueryFrameCountNV', 'wglResetFrameCountNV', 'PFNWGLJOINSWAPGROUPNVPROC',
'PFNWGLBINDSWAPBARRIERNVPROC', 'PFNWGLQUERYSWAPGROUPNVPROC',
'PFNWGLQUERYMAXSWAPGROUPSNVPROC', 'PFNWGLQUERYFRAMECOUNTNVPROC',
'PFNWGLRESETFRAMECOUNTNVPROC', 'WGL_NV_gpu_affinity', 'wglEnumGpusNV',
'wglEnumGpuDevicesNV', 'wglCreateAffinityDCNV', 'wglEnumGpusFromAffinityDCNV',
'wglDeleteDCNV', 'PFNWGLENUMGPUSNVPROC', 'PFNWGLENUMGPUDEVICESNVPROC',
'PFNWGLCREATEAFFINITYDCNVPROC', 'PFNWGLENUMGPUSFROMAFFINITYDCNVPROC',
'PFNWGLDELETEDCNVPROC']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Wrapper for C:\cygwin\home\Alex\pyglet\tools\wgl.h
Generated by tools/gengl.py.
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: gengl.py 601 2007-02-04 05:36:59Z Alex.Holkner $'
from ctypes import *
from pyglet.gl.lib import link_WGL as _link_function
from pyglet.gl.lib import c_ptrdiff_t
if not _link_function:
raise ImportError('opengl32.dll is not available.')
# BEGIN GENERATED CONTENT (do not edit below this line)
# This content is generated by tools/gengl.py.
# Wrapper for C:\cygwin\home\Alex\pyglet\tools\wgl.h
CONST = 0 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:14
GLenum = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:17
GLboolean = c_ubyte # C:\cygwin\home\Alex\pyglet\tools\wgl.h:18
GLbitfield = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:19
GLbyte = c_char # C:\cygwin\home\Alex\pyglet\tools\wgl.h:20
GLshort = c_short # C:\cygwin\home\Alex\pyglet\tools\wgl.h:21
GLint = c_int # C:\cygwin\home\Alex\pyglet\tools\wgl.h:22
GLsizei = c_int # C:\cygwin\home\Alex\pyglet\tools\wgl.h:23
GLubyte = c_ubyte # C:\cygwin\home\Alex\pyglet\tools\wgl.h:24
GLushort = c_ushort # C:\cygwin\home\Alex\pyglet\tools\wgl.h:25
GLuint = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:26
GLfloat = c_float # C:\cygwin\home\Alex\pyglet\tools\wgl.h:27
GLclampf = c_float # C:\cygwin\home\Alex\pyglet\tools\wgl.h:28
GLdouble = c_double # C:\cygwin\home\Alex\pyglet\tools\wgl.h:29
GLclampd = c_double # C:\cygwin\home\Alex\pyglet\tools\wgl.h:30
GLvoid = None # C:\cygwin\home\Alex\pyglet\tools\wgl.h:31
INT8 = c_char # C:\cygwin\home\Alex\pyglet\tools\wgl.h:33
PINT8 = c_char_p # C:\cygwin\home\Alex\pyglet\tools\wgl.h:33
INT16 = c_short # C:\cygwin\home\Alex\pyglet\tools\wgl.h:34
PINT16 = POINTER(c_short) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:34
INT32 = c_int # C:\cygwin\home\Alex\pyglet\tools\wgl.h:35
PINT32 = POINTER(c_int) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:35
UINT8 = c_ubyte # C:\cygwin\home\Alex\pyglet\tools\wgl.h:36
PUINT8 = POINTER(c_ubyte) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:36
UINT16 = c_ushort # C:\cygwin\home\Alex\pyglet\tools\wgl.h:37
PUINT16 = POINTER(c_ushort) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:37
UINT32 = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:38
PUINT32 = POINTER(c_uint) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:38
LONG32 = c_int # C:\cygwin\home\Alex\pyglet\tools\wgl.h:39
PLONG32 = POINTER(c_int) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:39
ULONG32 = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:40
PULONG32 = POINTER(c_uint) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:40
DWORD32 = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:41
PDWORD32 = POINTER(c_uint) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:41
INT64 = c_longlong # C:\cygwin\home\Alex\pyglet\tools\wgl.h:42
PINT64 = POINTER(c_longlong) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:42
UINT64 = c_ulonglong # C:\cygwin\home\Alex\pyglet\tools\wgl.h:43
PUINT64 = POINTER(c_ulonglong) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:43
VOID = None # C:\cygwin\home\Alex\pyglet\tools\wgl.h:45
LPVOID = POINTER(None) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:45
LPCSTR = c_char_p # C:\cygwin\home\Alex\pyglet\tools\wgl.h:46
CHAR = c_char # C:\cygwin\home\Alex\pyglet\tools\wgl.h:47
BYTE = c_ubyte # C:\cygwin\home\Alex\pyglet\tools\wgl.h:48
WORD = c_ushort # C:\cygwin\home\Alex\pyglet\tools\wgl.h:49
USHORT = c_ushort # C:\cygwin\home\Alex\pyglet\tools\wgl.h:49
UINT = c_uint # C:\cygwin\home\Alex\pyglet\tools\wgl.h:50
INT = c_int # C:\cygwin\home\Alex\pyglet\tools\wgl.h:51
INT_PTR = POINTER(c_int) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:51
BOOL = c_long # C:\cygwin\home\Alex\pyglet\tools\wgl.h:52
LONG = c_long # C:\cygwin\home\Alex\pyglet\tools\wgl.h:53
DWORD = c_ulong # C:\cygwin\home\Alex\pyglet\tools\wgl.h:54
FLOAT = c_float # C:\cygwin\home\Alex\pyglet\tools\wgl.h:55
COLORREF = DWORD # C:\cygwin\home\Alex\pyglet\tools\wgl.h:56
LPCOLORREF = POINTER(DWORD) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:56
HANDLE = POINTER(None) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:58
HGLRC = HANDLE # C:\cygwin\home\Alex\pyglet\tools\wgl.h:60
HDC = HANDLE # C:\cygwin\home\Alex\pyglet\tools\wgl.h:61
PROC = CFUNCTYPE(INT_PTR) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:63
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:65
wglCopyContext = _link_function('wglCopyContext', BOOL, [HGLRC, HGLRC, UINT], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:66
wglCreateContext = _link_function('wglCreateContext', HGLRC, [HDC], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:67
wglCreateLayerContext = _link_function('wglCreateLayerContext', HGLRC, [HDC, c_int], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:68
wglDeleteContext = _link_function('wglDeleteContext', BOOL, [HGLRC], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:69
wglGetCurrentContext = _link_function('wglGetCurrentContext', HGLRC, [], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:70
wglGetCurrentDC = _link_function('wglGetCurrentDC', HDC, [], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:71
wglGetProcAddress = _link_function('wglGetProcAddress', PROC, [LPCSTR], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:72
wglMakeCurrent = _link_function('wglMakeCurrent', BOOL, [HDC, HGLRC], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:73
wglShareLists = _link_function('wglShareLists', BOOL, [HGLRC, HGLRC], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:74
wglUseFontBitmapsA = _link_function('wglUseFontBitmapsA', BOOL, [HDC, DWORD, DWORD, DWORD], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:75
wglUseFontBitmapsW = _link_function('wglUseFontBitmapsW', BOOL, [HDC, DWORD, DWORD, DWORD], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:76
SwapBuffers = _link_function('SwapBuffers', BOOL, [HDC], None)
class struct__POINTFLOAT(Structure):
__slots__ = [
'x',
'y',
]
struct__POINTFLOAT._fields_ = [
('x', FLOAT),
('y', FLOAT),
]
POINTFLOAT = struct__POINTFLOAT # C:\cygwin\home\Alex\pyglet\tools\wgl.h:81
PPOINTFLOAT = POINTER(struct__POINTFLOAT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:81
class struct__GLYPHMETRICSFLOAT(Structure):
__slots__ = [
'gmfBlackBoxX',
'gmfBlackBoxY',
'gmfptGlyphOrigin',
'gmfCellIncX',
'gmfCellIncY',
]
struct__GLYPHMETRICSFLOAT._fields_ = [
('gmfBlackBoxX', FLOAT),
('gmfBlackBoxY', FLOAT),
('gmfptGlyphOrigin', POINTFLOAT),
('gmfCellIncX', FLOAT),
('gmfCellIncY', FLOAT),
]
GLYPHMETRICSFLOAT = struct__GLYPHMETRICSFLOAT # C:\cygwin\home\Alex\pyglet\tools\wgl.h:89
PGLYPHMETRICSFLOAT = POINTER(struct__GLYPHMETRICSFLOAT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:89
LPGLYPHMETRICSFLOAT = POINTER(struct__GLYPHMETRICSFLOAT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:89
WGL_FONT_LINES = 0 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:91
WGL_FONT_POLYGONS = 1 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:92
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:93
wglUseFontOutlinesA = _link_function('wglUseFontOutlinesA', BOOL, [HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, c_int, LPGLYPHMETRICSFLOAT], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:95
wglUseFontOutlinesW = _link_function('wglUseFontOutlinesW', BOOL, [HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, c_int, LPGLYPHMETRICSFLOAT], None)
class struct_tagLAYERPLANEDESCRIPTOR(Structure):
__slots__ = [
'nSize',
'nVersion',
'dwFlags',
'iPixelType',
'cColorBits',
'cRedBits',
'cRedShift',
'cGreenBits',
'cGreenShift',
'cBlueBits',
'cBlueShift',
'cAlphaBits',
'cAlphaShift',
'cAccumBits',
'cAccumRedBits',
'cAccumGreenBits',
'cAccumBlueBits',
'cAccumAlphaBits',
'cDepthBits',
'cStencilBits',
'cAuxBuffers',
'iLayerPlane',
'bReserved',
'crTransparent',
]
struct_tagLAYERPLANEDESCRIPTOR._fields_ = [
('nSize', WORD),
('nVersion', WORD),
('dwFlags', DWORD),
('iPixelType', BYTE),
('cColorBits', BYTE),
('cRedBits', BYTE),
('cRedShift', BYTE),
('cGreenBits', BYTE),
('cGreenShift', BYTE),
('cBlueBits', BYTE),
('cBlueShift', BYTE),
('cAlphaBits', BYTE),
('cAlphaShift', BYTE),
('cAccumBits', BYTE),
('cAccumRedBits', BYTE),
('cAccumGreenBits', BYTE),
('cAccumBlueBits', BYTE),
('cAccumAlphaBits', BYTE),
('cDepthBits', BYTE),
('cStencilBits', BYTE),
('cAuxBuffers', BYTE),
('iLayerPlane', BYTE),
('bReserved', BYTE),
('crTransparent', COLORREF),
]
LAYERPLANEDESCRIPTOR = struct_tagLAYERPLANEDESCRIPTOR # C:\cygwin\home\Alex\pyglet\tools\wgl.h:125
PLAYERPLANEDESCRIPTOR = POINTER(struct_tagLAYERPLANEDESCRIPTOR) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:125
LPLAYERPLANEDESCRIPTOR = POINTER(struct_tagLAYERPLANEDESCRIPTOR) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:125
LPD_DOUBLEBUFFER = 1 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:128
LPD_STEREO = 2 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:129
LPD_SUPPORT_GDI = 16 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:130
LPD_SUPPORT_OPENGL = 32 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:131
LPD_SHARE_DEPTH = 64 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:132
LPD_SHARE_STENCIL = 128 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:133
LPD_SHARE_ACCUM = 256 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:134
LPD_SWAP_EXCHANGE = 512 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:135
LPD_SWAP_COPY = 1024 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:136
LPD_TRANSPARENT = 4096 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:137
LPD_TYPE_RGBA = 0 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:139
LPD_TYPE_COLORINDEX = 1 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:140
WGL_SWAP_MAIN_PLANE = 1 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:143
WGL_SWAP_OVERLAY1 = 2 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:144
WGL_SWAP_OVERLAY2 = 4 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:145
WGL_SWAP_OVERLAY3 = 8 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:146
WGL_SWAP_OVERLAY4 = 16 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:147
WGL_SWAP_OVERLAY5 = 32 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:148
WGL_SWAP_OVERLAY6 = 64 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:149
WGL_SWAP_OVERLAY7 = 128 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:150
WGL_SWAP_OVERLAY8 = 256 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:151
WGL_SWAP_OVERLAY9 = 512 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:152
WGL_SWAP_OVERLAY10 = 1024 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:153
WGL_SWAP_OVERLAY11 = 2048 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:154
WGL_SWAP_OVERLAY12 = 4096 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:155
WGL_SWAP_OVERLAY13 = 8192 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:156
WGL_SWAP_OVERLAY14 = 16384 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:157
WGL_SWAP_OVERLAY15 = 32768 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:158
WGL_SWAP_UNDERLAY1 = 65536 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:159
WGL_SWAP_UNDERLAY2 = 131072 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:160
WGL_SWAP_UNDERLAY3 = 262144 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:161
WGL_SWAP_UNDERLAY4 = 524288 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:162
WGL_SWAP_UNDERLAY5 = 1048576 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:163
WGL_SWAP_UNDERLAY6 = 2097152 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:164
WGL_SWAP_UNDERLAY7 = 4194304 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:165
WGL_SWAP_UNDERLAY8 = 8388608 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:166
WGL_SWAP_UNDERLAY9 = 16777216 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:167
WGL_SWAP_UNDERLAY10 = 33554432 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:168
WGL_SWAP_UNDERLAY11 = 67108864 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:169
WGL_SWAP_UNDERLAY12 = 134217728 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:170
WGL_SWAP_UNDERLAY13 = 268435456 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:171
WGL_SWAP_UNDERLAY14 = 536870912 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:172
WGL_SWAP_UNDERLAY15 = 1073741824 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:173
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:175
wglDescribeLayerPlane = _link_function('wglDescribeLayerPlane', BOOL, [HDC, c_int, c_int, UINT, LPLAYERPLANEDESCRIPTOR], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:177
wglSetLayerPaletteEntries = _link_function('wglSetLayerPaletteEntries', c_int, [HDC, c_int, c_int, c_int, POINTER(COLORREF)], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:179
wglGetLayerPaletteEntries = _link_function('wglGetLayerPaletteEntries', c_int, [HDC, c_int, c_int, c_int, POINTER(COLORREF)], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:181
wglRealizeLayerPalette = _link_function('wglRealizeLayerPalette', BOOL, [HDC, c_int, BOOL], None)
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:182
wglSwapLayerBuffers = _link_function('wglSwapLayerBuffers', BOOL, [HDC, UINT], None)
class struct__WGLSWAP(Structure):
__slots__ = [
'hdc',
'uiFlags',
]
struct__WGLSWAP._fields_ = [
('hdc', HDC),
('uiFlags', UINT),
]
WGLSWAP = struct__WGLSWAP # C:\cygwin\home\Alex\pyglet\tools\wgl.h:188
PWGLSWAP = POINTER(struct__WGLSWAP) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:188
LPWGLSWAP = POINTER(struct__WGLSWAP) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:188
WGL_SWAPMULTIPLE_MAX = 16 # C:\cygwin\home\Alex\pyglet\tools\wgl.h:190
# C:\cygwin\home\Alex\pyglet\tools\wgl.h:192
wglSwapMultipleBuffers = _link_function('wglSwapMultipleBuffers', DWORD, [UINT, POINTER(WGLSWAP)], None)
class struct_tagRECT(Structure):
__slots__ = [
'left',
'top',
'right',
'bottom',
]
struct_tagRECT._fields_ = [
('left', LONG),
('top', LONG),
('right', LONG),
('bottom', LONG),
]
RECT = struct_tagRECT # C:\cygwin\home\Alex\pyglet\tools\wgl.h:200
PRECT = POINTER(struct_tagRECT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:200
NPRECT = POINTER(struct_tagRECT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:200
LPRECT = POINTER(struct_tagRECT) # C:\cygwin\home\Alex\pyglet\tools\wgl.h:200
__all__ = ['CONST', 'GLenum', 'GLboolean', 'GLbitfield', 'GLbyte', 'GLshort',
'GLint', 'GLsizei', 'GLubyte', 'GLushort', 'GLuint', 'GLfloat', 'GLclampf',
'GLdouble', 'GLclampd', 'GLvoid', 'INT8', 'PINT8', 'INT16', 'PINT16', 'INT32',
'PINT32', 'UINT8', 'PUINT8', 'UINT16', 'PUINT16', 'UINT32', 'PUINT32',
'LONG32', 'PLONG32', 'ULONG32', 'PULONG32', 'DWORD32', 'PDWORD32', 'INT64',
'PINT64', 'UINT64', 'PUINT64', 'VOID', 'LPVOID', 'LPCSTR', 'CHAR', 'BYTE',
'WORD', 'USHORT', 'UINT', 'INT', 'INT_PTR', 'BOOL', 'LONG', 'DWORD', 'FLOAT',
'COLORREF', 'LPCOLORREF', 'HANDLE', 'HGLRC', 'HDC', 'PROC', 'wglCopyContext',
'wglCreateContext', 'wglCreateLayerContext', 'wglDeleteContext',
'wglGetCurrentContext', 'wglGetCurrentDC', 'wglGetProcAddress',
'wglMakeCurrent', 'wglShareLists', 'wglUseFontBitmapsA', 'wglUseFontBitmapsW',
'SwapBuffers', 'POINTFLOAT', 'PPOINTFLOAT', 'GLYPHMETRICSFLOAT',
'PGLYPHMETRICSFLOAT', 'LPGLYPHMETRICSFLOAT', 'WGL_FONT_LINES',
'WGL_FONT_POLYGONS', 'wglUseFontOutlinesA', 'wglUseFontOutlinesW',
'LAYERPLANEDESCRIPTOR', 'PLAYERPLANEDESCRIPTOR', 'LPLAYERPLANEDESCRIPTOR',
'LPD_DOUBLEBUFFER', 'LPD_STEREO', 'LPD_SUPPORT_GDI', 'LPD_SUPPORT_OPENGL',
'LPD_SHARE_DEPTH', 'LPD_SHARE_STENCIL', 'LPD_SHARE_ACCUM',
'LPD_SWAP_EXCHANGE', 'LPD_SWAP_COPY', 'LPD_TRANSPARENT', 'LPD_TYPE_RGBA',
'LPD_TYPE_COLORINDEX', 'WGL_SWAP_MAIN_PLANE', 'WGL_SWAP_OVERLAY1',
'WGL_SWAP_OVERLAY2', 'WGL_SWAP_OVERLAY3', 'WGL_SWAP_OVERLAY4',
'WGL_SWAP_OVERLAY5', 'WGL_SWAP_OVERLAY6', 'WGL_SWAP_OVERLAY7',
'WGL_SWAP_OVERLAY8', 'WGL_SWAP_OVERLAY9', 'WGL_SWAP_OVERLAY10',
'WGL_SWAP_OVERLAY11', 'WGL_SWAP_OVERLAY12', 'WGL_SWAP_OVERLAY13',
'WGL_SWAP_OVERLAY14', 'WGL_SWAP_OVERLAY15', 'WGL_SWAP_UNDERLAY1',
'WGL_SWAP_UNDERLAY2', 'WGL_SWAP_UNDERLAY3', 'WGL_SWAP_UNDERLAY4',
'WGL_SWAP_UNDERLAY5', 'WGL_SWAP_UNDERLAY6', 'WGL_SWAP_UNDERLAY7',
'WGL_SWAP_UNDERLAY8', 'WGL_SWAP_UNDERLAY9', 'WGL_SWAP_UNDERLAY10',
'WGL_SWAP_UNDERLAY11', 'WGL_SWAP_UNDERLAY12', 'WGL_SWAP_UNDERLAY13',
'WGL_SWAP_UNDERLAY14', 'WGL_SWAP_UNDERLAY15', 'wglDescribeLayerPlane',
'wglSetLayerPaletteEntries', 'wglGetLayerPaletteEntries',
'wglRealizeLayerPalette', 'wglSwapLayerBuffers', 'WGLSWAP', 'PWGLSWAP',
'LPWGLSWAP', 'WGL_SWAPMULTIPLE_MAX', 'wglSwapMultipleBuffers', 'RECT',
'PRECT', 'NPRECT', 'LPRECT']
# END GENERATED CONTENT (do not edit above this line)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from ctypes import *
import pyglet.lib
from pyglet.gl.lib import missing_function, decorate_function
__all__ = ['link_GL', 'link_GLU', 'link_AGL']
gl_lib = pyglet.lib.load_library(
framework='/System/Library/Frameworks/OpenGL.framework')
agl_lib = pyglet.lib.load_library(
framework='/System/Library/Frameworks/AGL.framework')
def link_GL(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(gl_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
return missing_function(name, requires, suggestions)
link_GLU = link_GL
def link_AGL(name, restype, argtypes, requires=None, suggestions=None):
try:
func = getattr(agl_lib, name)
func.restype = restype
func.argtypes = argtypes
decorate_function(func, name)
return func
except AttributeError:
return missing_function(name, requires, suggestions)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id:$
'''Provides keyboard and mouse editing procedures for text layout.
Example usage::
from pyglet import window
from pyglet.text import layout, caret
my_window = window.Window(...)
my_layout = layout.IncrementalTextLayout(...)
my_caret = caret.Caret(my_layout)
my_window.push_handlers(my_caret)
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import re
import time
from pyglet import clock
from pyglet import event
from pyglet.window import key
class Caret(object):
'''Visible text insertion marker for
`pyglet.text.layout.IncrementalTextLayout`.
The caret is drawn as a single vertical bar at the document `position`
on a text layout object. If `mark` is not None, it gives the unmoving
end of the current text selection. The visible text selection on the
layout is updated along with `mark` and `position`.
By default the layout's graphics batch is used, so the caret does not need
to be drawn explicitly. Even if a different graphics batch is supplied,
the caret will be correctly positioned and clipped within the layout.
Updates to the document (and so the layout) are automatically propagated
to the caret.
The caret object can be pushed onto a window event handler stack with
`Window.push_handlers`. The caret will respond correctly to keyboard,
text, mouse and activation events, including double- and triple-clicks.
If the text layout is being used alongside other graphical widgets, a
GUI toolkit will be needed to delegate keyboard and mouse events to the
appropriate widget. pyglet does not provide such a toolkit at this stage.
'''
_next_word_re = re.compile(r'(?<=\W)\w')
_previous_word_re = re.compile(r'(?<=\W)\w+\W*$')
_next_para_re = re.compile(r'\n', flags=re.DOTALL)
_previous_para_re = re.compile(r'\n', flags=re.DOTALL)
_position = 0
_active = True
_visible = True
_blink_visible = True
_click_count = 0
_click_time = 0
#: Blink period, in seconds.
PERIOD = 0.5
#: Pixels to scroll viewport per mouse scroll wheel movement. Defaults
#: to 12pt at 96dpi.
SCROLL_INCREMENT= 12 * 96 // 72
def __init__(self, layout, batch=None, color=(0, 0, 0)):
'''Create a caret for a layout.
By default the layout's batch is used, so the caret does not need to
be drawn explicitly.
:Parameters:
`layout` : `TextLayout`
Layout to control.
`batch` : `Batch`
Graphics batch to add vertices to.
`color` : (int, int, int)
RGB tuple with components in range [0, 255].
'''
from pyglet import gl
self._layout = layout
if batch is None:
batch = layout.batch
r, g, b = color
colors = (r, g, b, 255, r, g, b, 255)
self._list = batch.add(2, gl.GL_LINES, layout.background_group,
'v2f', ('c4B', colors))
self._ideal_x = None
self._ideal_line = None
self._next_attributes = {}
self.visible = True
layout.push_handlers(self)
def delete(self):
'''Remove the caret from its batch.
Also disconnects the caret from further layout events.
'''
self._list.delete()
self._layout.remove_handlers(self)
def _blink(self, dt):
if self.PERIOD:
self._blink_visible = not self._blink_visible
if self._visible and self._active and self._blink_visible:
alpha = 255
else:
alpha = 0
self._list.colors[3] = alpha
self._list.colors[7] = alpha
def _nudge(self):
self.visible = True
def _set_visible(self, visible):
self._visible = visible
clock.unschedule(self._blink)
if visible and self._active and self.PERIOD:
clock.schedule_interval(self._blink, self.PERIOD)
self._blink_visible = False # flipped immediately by next blink
self._blink(0)
def _get_visible(self):
return self._visible
visible = property(_get_visible, _set_visible,
doc='''Caret visibility.
The caret may be hidden despite this property due to the periodic blinking
or by `on_deactivate` if the event handler is attached to a window.
:type: bool
''')
def _set_color(self, color):
self._list.colors[:3] = color
self._list.colors[4:7] = color
def _get_color(self):
return self._list.colors[:3]
color = property(_get_color, _set_color,
doc='''Caret color.
The default caret color is ``[0, 0, 0]`` (black). Each RGB color
component is in the range 0 to 255.
:type: (int, int, int)
''')
def _set_position(self, index):
self._position = index
self._next_attributes.clear()
self._update()
def _get_position(self):
return self._position
position = property(_get_position, _set_position,
doc='''Position of caret within document.
:type: int
''')
_mark = None
def _set_mark(self, mark):
self._mark = mark
self._update(line=self._ideal_line)
if mark is None:
self._layout.set_selection(0, 0)
def _get_mark(self):
return self._mark
mark = property(_get_mark, _set_mark,
doc='''Position of immovable end of text selection within
document.
An interactive text selection is determined by its immovable end (the
caret's position when a mouse drag begins) and the caret's position, which
moves interactively by mouse and keyboard input.
This property is ``None`` when there is no selection.
:type: int
''')
def _set_line(self, line):
if self._ideal_x is None:
self._ideal_x, _ = \
self._layout.get_point_from_position(self._position)
self._position = \
self._layout.get_position_on_line(line, self._ideal_x)
self._update(line=line, update_ideal_x=False)
def _get_line(self):
if self._ideal_line is not None:
return self._ideal_line
else:
return self._layout.get_line_from_position(self._position)
line = property(_get_line, _set_line,
doc='''Index of line containing the caret's position.
When set, `position` is modified to place the caret on requested line
while maintaining the closest possible X offset.
:type: int
''')
def get_style(self, attribute):
'''Get the document's named style at the caret's current position.
If there is a text selection and the style varies over the selection,
`pyglet.text.document.STYLE_INDETERMINATE` is returned.
:Parameters:
`attribute` : str
Name of style attribute to retrieve. See
`pyglet.text.document` for a list of recognised attribute
names.
:rtype: object
'''
if self._mark is None or self._mark == self._position:
try:
return self._next_attributes[attribute]
except KeyError:
return self._layout.document.get_style(attribute,
self._position)
start = min(self._position, self._mark)
end = max(self._position, self._mark)
return self._layout.document.get_style_range(attribute, start, end)
def set_style(self, attributes):
'''Set the document style at the caret's current position.
If there is a text selection the style is modified immediately.
Otherwise, the next text that is entered before the position is
modified will take on the given style.
:Parameters:
`attributes` : dict
Dict mapping attribute names to style values. See
`pyglet.text.document` for a list of recognised attribute
names.
'''
if self._mark is None or self._mark == self._position:
self._next_attributes.update(attributes)
return
start = min(self._position, self._mark)
end = max(self._position, self._mark)
self._layout.document.set_style(start, end, attributes)
def _delete_selection(self):
start = min(self._mark, self._position)
end = max(self._mark, self._position)
self._position = start
self._mark = None
self._layout.document.delete_text(start, end)
self._layout.set_selection(0, 0)
def move_to_point(self, x, y):
'''Move the caret close to the given window coordinate.
The `mark` will be reset to ``None``.
:Parameters:
`x` : int
X coordinate.
`y` : int
Y coordinate.
'''
line = self._layout.get_line_from_point(x, y)
self._mark = None
self._layout.set_selection(0, 0)
self._position = self._layout.get_position_on_line(line, x)
self._update(line=line)
self._next_attributes.clear()
def select_to_point(self, x, y):
'''Move the caret close to the given window coordinate while
maintaining the `mark`.
:Parameters:
`x` : int
X coordinate.
`y` : int
Y coordinate.
'''
line = self._layout.get_line_from_point(x, y)
self._position = self._layout.get_position_on_line(line, x)
self._update(line=line)
self._next_attributes.clear()
def select_word(self, x, y):
'''Select the word at the given window coordinate.
:Parameters:
`x` : int
X coordinate.
`y` : int
Y coordinate.
'''
line = self._layout.get_line_from_point(x, y)
p = self._layout.get_position_on_line(line, x)
m1 = self._previous_word_re.search(self._layout.document.text,
0, p+1)
if not m1:
m1 = 0
else:
m1 = m1.start()
self.mark = m1
m2 = self._next_word_re.search(self._layout.document.text, p)
if not m2:
m2 = len(self._layout.document.text)
else:
m2 = m2.start()
self._position = m2
self._update(line=line)
self._next_attributes.clear()
def select_paragraph(self, x, y):
'''Select the paragraph at the given window coordinate.
:Parameters:
`x` : int
X coordinate.
`y` : int
Y coordinate.
'''
line = self._layout.get_line_from_point(x, y)
p = self._layout.get_position_on_line(line, x)
self.mark = self._layout.document.get_paragraph_start(p)
self._position = self._layout.document.get_paragraph_end(p)
self._update(line=line)
self._next_attributes.clear()
def _update(self, line=None, update_ideal_x=True):
if line is None:
line = self._layout.get_line_from_position(self._position)
self._ideal_line = None
else:
self._ideal_line = line
x, y = self._layout.get_point_from_position(self._position, line)
if update_ideal_x:
self._ideal_x = x
x -= self._layout.top_group.translate_x
y -= self._layout.top_group.translate_y
font = self._layout.document.get_font(max(0, self._position - 1))
self._list.vertices[:] = [x, y + font.descent, x, y + font.ascent]
if self._mark is not None:
self._layout.set_selection(min(self._position, self._mark),
max(self._position, self._mark))
self._layout.ensure_line_visible(line)
self._layout.ensure_x_visible(x)
def on_layout_update(self):
if self.position > len(self._layout.document.text):
self.position = len(self._layout.document.text)
self._update()
def on_text(self, text):
'''Handler for the `pyglet.window.Window.on_text` event.
Caret keyboard handlers assume the layout always has keyboard focus.
GUI toolkits should filter keyboard and text events by widget focus
before invoking this handler.
'''
if self._mark is not None:
self._delete_selection()
text = text.replace('\r', '\n')
pos = self._position
self._position += len(text)
self._layout.document.insert_text(pos, text, self._next_attributes)
self._nudge()
return event.EVENT_HANDLED
def on_text_motion(self, motion, select=False):
'''Handler for the `pyglet.window.Window.on_text_motion` event.
Caret keyboard handlers assume the layout always has keyboard focus.
GUI toolkits should filter keyboard and text events by widget focus
before invoking this handler.
'''
if motion == key.MOTION_BACKSPACE:
if self.mark is not None:
self._delete_selection()
elif self._position > 0:
self._position -= 1
self._layout.document.delete_text(
self._position, self._position + 1)
elif motion == key.MOTION_DELETE:
if self.mark is not None:
self._delete_selection()
elif self._position < len(self._layout.document.text):
self._layout.document.delete_text(
self._position, self._position + 1)
elif self._mark is not None and not select:
self._mark = None
self._layout.set_selection(0, 0)
if motion == key.MOTION_LEFT:
self.position = max(0, self.position - 1)
elif motion == key.MOTION_RIGHT:
self.position = min(len(self._layout.document.text),
self.position + 1)
elif motion == key.MOTION_UP:
self.line = max(0, self.line - 1)
elif motion == key.MOTION_DOWN:
line = self.line
if line < self._layout.get_line_count() - 1:
self.line = line + 1
elif motion == key.MOTION_BEGINNING_OF_LINE:
self.position = self._layout.get_position_from_line(self.line)
elif motion == key.MOTION_END_OF_LINE:
line = self.line
if line < self._layout.get_line_count() - 1:
self._position = \
self._layout.get_position_from_line(line + 1) - 1
self._update(line)
else:
self.position = len(self._layout.document.text)
elif motion == key.MOTION_BEGINNING_OF_FILE:
self.position = 0
elif motion == key.MOTION_END_OF_FILE:
self.position = len(self._layout.document.text)
elif motion == key.MOTION_NEXT_WORD:
pos = self._position + 1
m = self._next_word_re.search(self._layout.document.text, pos)
if not m:
self.position = len(self._layout.document.text)
else:
self.position = m.start()
elif motion == key.MOTION_PREVIOUS_WORD:
pos = self._position
m = self._previous_word_re.search(self._layout.document.text,
0, pos)
if not m:
self.position = 0
else:
self.position = m.start()
self._next_attributes.clear()
self._nudge()
return event.EVENT_HANDLED
def on_text_motion_select(self, motion):
'''Handler for the `pyglet.window.Window.on_text_motion_select` event.
Caret keyboard handlers assume the layout always has keyboard focus.
GUI toolkits should filter keyboard and text events by widget focus
before invoking this handler.
'''
if self.mark is None:
self.mark = self.position
self.on_text_motion(motion, True)
return event.EVENT_HANDLED
def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
'''Handler for the `pyglet.window.Window.on_mouse_scroll` event.
Mouse handlers do not check the bounds of the coordinates: GUI
toolkits should filter events that do not intersect the layout
before invoking this handler.
The layout viewport is scrolled by `SCROLL_INCREMENT` pixels per
"click".
'''
self._layout.view_x -= scroll_x * self.SCROLL_INCREMENT
self._layout.view_y += scroll_y * self.SCROLL_INCREMENT
return event.EVENT_HANDLED
def on_mouse_press(self, x, y, button, modifiers):
'''Handler for the `pyglet.window.Window.on_mouse_press` event.
Mouse handlers do not check the bounds of the coordinates: GUI
toolkits should filter events that do not intersect the layout
before invoking this handler.
This handler keeps track of the number of mouse presses within
a short span of time and uses this to reconstruct double- and
triple-click events for selecting words and paragraphs. This
technique is not suitable when a GUI toolkit is in use, as the active
widget must also be tracked. Do not use this mouse handler if
a GUI toolkit is being used.
'''
t = time.time()
if t - self._click_time < 0.25:
self._click_count += 1
else:
self._click_count = 1
self._click_time = time.time()
if self._click_count == 1:
self.move_to_point(x, y)
elif self._click_count == 2:
self.select_word(x, y)
elif self._click_count == 3:
self.select_paragraph(x, y)
self._click_count = 0
self._nudge()
return event.EVENT_HANDLED
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
'''Handler for the `pyglet.window.Window.on_mouse_drag` event.
Mouse handlers do not check the bounds of the coordinates: GUI
toolkits should filter events that do not intersect the layout
before invoking this handler.
'''
if self.mark is None:
self.mark = self.position
self.select_to_point(x, y)
self._nudge()
return event.EVENT_HANDLED
def on_activate(self):
'''Handler for the `pyglet.window.Window.on_activate` event.
The caret is hidden when the window is not active.
'''
self._active = True
self.visible = self._active
return event.EVENT_HANDLED
def on_deactivate(self):
'''Handler for the `pyglet.window.Window.on_deactivate` event.
The caret is hidden when the window is not active.
'''
self._active = False
self.visible = self._active
return event.EVENT_HANDLED
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Run list encoding utilities.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
class _Run(object):
def __init__(self, value, count):
self.value = value
self.count = count
def __repr__(self):
return 'Run(%r, %d)' % (self.value, self.count)
class RunList(object):
'''List of contiguous runs of values.
A `RunList` is an efficient encoding of a sequence of values. For
example, the sequence ``aaaabbccccc`` is encoded as ``(4, a), (2, b),
(5, c)``. The class provides methods for modifying and querying the
run list without needing to deal with the tricky cases of splitting and
merging the run list entries.
Run lists are used to represent formatted character data in pyglet. A
separate run list is maintained for each style attribute, for example,
bold, italic, font size, and so on. Unless you are overriding the
document interfaces, the only interaction with run lists is via
`RunIterator`.
The length and ranges of a run list always refer to the character
positions in the decoded list. For example, in the above sequence,
``set_run(2, 5, 'x')`` would change the sequence to ``aaxxxbccccc``.
'''
def __init__(self, size, initial):
'''Create a run list of the given size and a default value.
:Parameters:
`size` : int
Number of characters to represent initially.
`initial` : object
The value of all characters in the run list.
'''
self.runs = [_Run(initial, size)]
def insert(self, pos, length):
'''Insert characters into the run list.
The inserted characters will take on the value immediately preceding
the insertion point (or the value of the first character, if `pos` is
0).
:Parameters:
`pos` : int
Insertion index
`length` : int
Number of characters to insert.
'''
i = 0
for run in self.runs:
if i <= pos <= i + run.count:
run.count += length
i += run.count
def delete(self, start, end):
'''Remove characters from the run list.
:Parameters:
`start` : int
Starting index to remove from.
`end` : int
End index, exclusive.
'''
i = 0
for run in self.runs:
if end - start == 0:
break
if i <= start <= i + run.count:
trim = min(end - start, i + run.count - start)
run.count -= trim
end -= trim
i += run.count
self.runs = [r for r in self.runs if r.count > 0]
# Don't leave an empty list
if not self.runs:
self.runs = [_Run(run.value, 0)]
def set_run(self, start, end, value):
'''Set the value of a range of characters.
:Parameters:
`start` : int
Start index of range.
`end` : int
End of range, exclusive.
`value` : object
Value to set over the range.
'''
if end - start <= 0:
return
# Find runs that need to be split
i = 0
start_i = None
start_trim = 0
end_i = None
end_trim = 0
for run_i, run in enumerate(self.runs):
count = run.count
if i < start < i + count:
start_i = run_i
start_trim = start - i
if i < end < i + count:
end_i = run_i
end_trim = end - i
i += count
# Split runs
if start_i is not None:
run = self.runs[start_i]
self.runs.insert(start_i, _Run(run.value, start_trim))
run.count -= start_trim
if end_i is not None:
if end_i == start_i:
end_trim -= start_trim
end_i += 1
if end_i is not None:
run = self.runs[end_i]
self.runs.insert(end_i, _Run(run.value, end_trim))
run.count -= end_trim
# Set new value on runs
i = 0
for run in self.runs:
if start <= i and i + run.count <= end:
run.value = value
i += run.count
# Merge adjacent runs
last_run = self.runs[0]
for run in self.runs[1:]:
if run.value == last_run.value:
run.count += last_run.count
last_run.count = 0
last_run = run
# Delete collapsed runs
self.runs = [r for r in self.runs if r.count > 0]
def __iter__(self):
i = 0
for run in self.runs:
yield i, i + run.count, run.value
i += run.count
def get_run_iterator(self):
'''Get an extended iterator over the run list.
:rtype: `RunIterator`
'''
return RunIterator(self)
def __getitem__(self, index):
'''Get the value at a character position.
:Parameters:
`index` : int
Index of character. Must be within range and non-negative.
:rtype: object
'''
i = 0
for run in self.runs:
if i <= index < i + run.count:
return run.value
i += run.count
# Append insertion point
if index == i:
return self.runs[-1].value
assert False, 'Index not in range'
def __repr__(self):
return str(list(self))
class AbstractRunIterator(object):
'''Range iteration over `RunList`.
`AbstractRunIterator` objects allow any monotonically non-decreasing
access of the iteration, including repeated iteration over the same index.
Use the ``[index]`` operator to get the value at a particular index within
the document. For example::
run_iter = iter(run_list)
value = run_iter[0]
value = run_iter[0] # non-decreasing access is OK
value = run_iter[15]
value = run_iter[17]
value = run_iter[16] # this is illegal, the index decreased.
Using `AbstractRunIterator` to access increasing indices of the value runs
is more efficient than calling `RunList.__getitem__` repeatedly.
You can also iterate over monotonically non-decreasing ranges over the
iteration. For example::
run_iter = iter(run_list)
for start, end, value in run_iter.ranges(0, 20):
pass
for start, end, value in run_iter.ranges(25, 30):
pass
for start, end, value in run_iter.ranges(30, 40):
pass
Both start and end indices of the slice are required and must be positive.
'''
def __getitem__(self, index):
'''Get the value at a given index.
See the class documentation for examples of valid usage.
:Parameters:
`index` : int
Document position to query.
:rtype: object
'''
def ranges(self, start, end):
'''Iterate over a subrange of the run list.
See the class documentation for examples of valid usage.
:Parameters:
`start` : int
Start index to iterate from.
`end` : int
End index, exclusive.
:rtype: iterator
:return: Iterator over (start, end, value) tuples.
'''
class RunIterator(AbstractRunIterator):
def __init__(self, run_list):
self._run_list_iter = iter(run_list)
self.start, self.end, self.value = self.next()
def next(self):
return self._run_list_iter.next()
def __getitem__(self, index):
while index >= self.end and index > self.start:
# condition has special case for 0-length run (fixes issue 471)
self.start, self.end, self.value = self.next()
return self.value
def ranges(self, start, end):
while start >= self.end:
self.start, self.end, self.value = self.next()
yield start, min(self.end, end), self.value
while end > self.end:
self.start, self.end, self.value = self.next()
yield self.start, min(self.end, end), self.value
class OverriddenRunIterator(AbstractRunIterator):
'''Iterator over a `RunIterator`, with a value temporarily replacing
a given range.
'''
def __init__(self, base_iterator, start, end, value):
'''Create a derived iterator.
:Parameters:
`start` : int
Start of range to override
`end` : int
End of range to override, exclusive
`value` : object
Value to replace over the range
'''
self.iter = base_iterator
self.override_start = start
self.override_end = end
self.override_value = value
def ranges(self, start, end):
if end <= self.override_start or start >= self.override_end:
# No overlap
for r in self.iter.ranges(start, end):
yield r
else:
# Overlap: before, override, after
if start < self.override_start < end:
for r in self.iter.ranges(start, self.override_start):
yield r
yield (max(self.override_start, start),
min(self.override_end, end),
self.override_value)
if start < self.override_end < end:
for r in self.iter.ranges(self.override_end, end):
yield r
def __getitem__(self, index):
if self.override_start <= index < self.override_end:
return self.override_value
else:
return self.iter[index]
class FilteredRunIterator(AbstractRunIterator):
'''Iterate over an `AbstractRunIterator` with filtered values replaced
by a default value.
'''
def __init__(self, base_iterator, filter, default):
'''Create a filtered run iterator.
:Parameters:
`base_iterator` : `AbstractRunIterator`
Source of runs.
`filter` : ``lambda object: bool``
Function taking a value as parameter, and returning ``True``
if the value is acceptable, and ``False`` if the default value
should be substituted.
`default` : object
Default value to replace filtered values.
'''
self.iter = base_iterator
self.filter = filter
self.default = default
def ranges(self, start, end):
for start, end, value in self.iter.ranges(start, end):
if self.filter(value):
yield start, end, value
else:
yield start, end, self.default
def __getitem__(self, index):
value = self.iter[index]
if self.filter(value):
return value
return self.default
class ZipRunIterator(AbstractRunIterator):
'''Iterate over multiple run iterators concurrently.'''
def __init__(self, range_iterators):
self.range_iterators = range_iterators
def ranges(self, start, end):
iterators = [i.ranges(start, end) for i in self.range_iterators]
starts, ends, values = zip(*[i.next() for i in iterators])
starts = list(starts)
ends = list(ends)
values = list(values)
while start < end:
min_end = min(ends)
yield start, min_end, values
start = min_end
for i, iterator in enumerate(iterators):
if ends[i] == min_end:
starts[i], ends[i], values[i] = iterator.next()
def __getitem__(self, index):
return [i[index] for i in self.range_iterators]
class ConstRunIterator(AbstractRunIterator):
'''Iterate over a constant value without creating a RunList.'''
def __init__(self, length, value):
self.length = length
self.value = value
def next(self):
yield 0, self.length, self.value
def ranges(self, start, end):
yield start, end, self.value
def __getitem__(self, index):
return self.value
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id: $
'''Render simple text and formatted documents efficiently.
Three layout classes are provided:
`TextLayout`
The entire document is laid out before it is rendered. The layout will
be grouped with other layouts in the same batch (allowing for efficient
rendering of multiple layouts).
Any change to the layout or document,
and even querying some properties, will cause the entire document
to be laid out again.
`ScrollableTextLayout`
Based on `TextLayout`.
A separate group is used for layout which crops the contents of the
layout to the layout rectangle. Additionally, the contents of the
layout can be "scrolled" within that rectangle with the ``view_x`` and
``view_y`` properties.
`IncrementalTextLayout`
Based on `ScrollableTextLayout`.
When the layout or document are modified, only the affected regions
are laid out again. This permits efficient interactive editing and
styling of text.
Only the visible portion of the layout is actually rendered; as the
viewport is scrolled additional sections are rendered and discarded as
required. This permits efficient viewing and editing of large documents.
Additionally, this class provides methods for locating the position of a
caret in the document, and for displaying interactive text selections.
All three layout classes can be used with either `UnformattedDocument` or
`FormattedDocument`, and can be either single-line or ``multiline``. The
combinations of these options effectively provides 12 different text display
possibilities.
Style attributes
================
The following character style attribute names are recognised by the layout
classes. Data types and units are as specified.
Where an attribute is marked "as a distance" the value is assumed to be
in pixels if given as an int or float, otherwise a string of the form
``"0u"`` is required, where ``0`` is the distance and ``u`` is the unit; one
of ``"px"`` (pixels), ``"pt"`` (points), ``"pc"`` (picas), ``"cm"``
(centimeters), ``"mm"`` (millimeters) or ``"in"`` (inches). For example,
``"14pt"`` is the distance covering 14 points, which at the default DPI of 96
is 18 pixels.
``font_name``
Font family name, as given to `pyglet.font.load`.
``font_size``
Font size, in points.
``bold``
Boolean.
``italic``
Boolean.
``underline``
4-tuple of ints in range (0, 255) giving RGBA underline color, or None
(default) for no underline.
``kerning``
Additional space to insert between glyphs, as a distance. Defaults to 0.
``baseline``
Offset of glyph baseline from line baseline, as a distance. Positive
values give a superscript, negative values give a subscript. Defaults to
0.
``color``
4-tuple of ints in range (0, 255) giving RGBA text color
``background_color``
4-tuple of ints in range (0, 255) giving RGBA text background color; or
``None`` for no background fill.
The following paragraph style attribute names are recognised. Note
that paragraph styles are handled no differently from character styles by the
document: it is the application's responsibility to set the style over an
entire paragraph, otherwise results are undefined.
``align``
``left`` (default), ``center`` or ``right``.
``indent``
Additional horizontal space to insert before the first glyph of the
first line of a paragraph, as a distance.
``leading``
Additional space to insert between consecutive lines within a paragraph,
as a distance. Defaults to 0.
``line_spacing``
Distance between consecutive baselines in a paragraph, as a distance.
Defaults to ``None``, which automatically calculates the tightest line
spacing for each line based on the font ascent and descent.
``margin_left``
Left paragraph margin, as a distance.
``margin_right``
Right paragraph margin, as a distance.
``margin_top``
Margin above paragraph, as a distance.
``margin_bottom``
Margin below paragraph, as a distance. Adjacent margins do not collapse.
``tab_stops``
List of horizontal tab stops, as distances, measured from the left edge of
the text layout. Defaults to the empty list. When the tab stops
are exhausted, they implicitly continue at 50 pixel intervals.
``wrap``
``char``, ``word``, True (default) or False. The boundaries at which to
wrap text to prevent it overflowing a line. With ``char``, the line
wraps anywhere in the text; with ``word`` or True, the line wraps at
appropriate boundaries between words; with False the line does not wrap,
and may overflow the layout width. ``char`` and ``word`` styles are
since pyglet 1.2.
Other attributes can be used to store additional style information within the
document; they will be ignored by the built-in text classes.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import re
import sys
from pyglet.gl import *
from pyglet import event
from pyglet import graphics
from pyglet.text import runlist
from pyglet.font.base import _grapheme_break
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
_distance_re = re.compile(r'([-0-9.]+)([a-zA-Z]+)')
def _parse_distance(distance, dpi):
'''Parse a distance string and return corresponding distance in pixels as
an integer.
'''
if isinstance(distance, int):
return distance
elif isinstance(distance, float):
return int(distance)
match = _distance_re.match(distance)
assert match, 'Could not parse distance %s' % (distance)
if not match:
return 0
value, unit = match.groups()
value = float(value)
if unit == 'px':
return int(value)
elif unit == 'pt':
return int(value * dpi / 72.0)
elif unit == 'pc':
return int(value * dpi / 6.0)
elif unit == 'in':
return int(value * dpi)
elif unit == 'mm':
return int(value * dpi * 0.0393700787)
elif unit == 'cm':
return int(value * dpi * 0.393700787)
else:
assert False, 'Unknown distance unit %s' % unit
class _Line(object):
align = 'left'
margin_left = 0
margin_right = 0
length = 0
ascent = 0
descent = 0
width = 0
paragraph_begin = False
paragraph_end = False
x = None
y = None
def __init__(self, start):
self.vertex_lists = []
self.start = start
self.boxes = []
def __repr__(self):
return '_Line(%r)' % self.boxes
def add_box(self, box):
self.boxes.append(box)
self.length += box.length
self.ascent = max(self.ascent, box.ascent)
self.descent = min(self.descent, box.descent)
self.width += box.advance
def delete(self, layout):
for vertex_list in self.vertex_lists:
vertex_list.delete()
self.vertex_lists = []
for box in self.boxes:
box.delete(layout)
class _LayoutContext(object):
def __init__(self, layout, document, colors_iter, background_iter):
self.colors_iter = colors_iter
underline_iter = document.get_style_runs('underline')
self.decoration_iter = runlist.ZipRunIterator(
(background_iter,
underline_iter))
self.baseline_iter = runlist.FilteredRunIterator(
document.get_style_runs('baseline'),
lambda value: value is not None, 0)
class _StaticLayoutContext(_LayoutContext):
def __init__(self, layout, document, colors_iter, background_iter):
super(_StaticLayoutContext, self).__init__(layout, document,
colors_iter, background_iter)
self.vertex_lists = layout._vertex_lists
self.boxes = layout._boxes
def add_list(self, vertex_list):
self.vertex_lists.append(vertex_list)
def add_box(self, box):
self.boxes.append(box)
class _IncrementalLayoutContext(_LayoutContext):
line = None
def add_list(self, vertex_list):
self.line.vertex_lists.append(vertex_list)
def add_box(self, box):
pass
class _AbstractBox(object):
owner = None
def __init__(self, ascent, descent, advance, length):
self.ascent = ascent
self.descent = descent
self.advance = advance
self.length = length
def place(self, layout, i, x, y):
raise NotImplementedError('abstract')
def delete(self, layout):
raise NotImplementedError('abstract')
def get_position_in_box(self, x):
raise NotImplementedError('abstract')
def get_point_in_box(self, position):
raise NotImplementedError('abstract')
class _GlyphBox(_AbstractBox):
def __init__(self, owner, font, glyphs, advance):
'''Create a run of glyphs sharing the same texture.
:Parameters:
`owner` : `pyglet.image.Texture`
Texture of all glyphs in this run.
`font` : `pyglet.font.base.Font`
Font of all glyphs in this run.
`glyphs` : list of (int, `pyglet.font.base.Glyph`)
Pairs of ``(kern, glyph)``, where ``kern`` gives horizontal
displacement of the glyph in pixels (typically 0).
`advance` : int
Width of glyph run; must correspond to the sum of advances
and kerns in the glyph list.
'''
super(_GlyphBox, self).__init__(
font.ascent, font.descent, advance, len(glyphs))
assert owner
self.owner = owner
self.font = font
self.glyphs = glyphs
self.advance = advance
def place(self, layout, i, x, y, context):
assert self.glyphs
try:
group = layout.groups[self.owner]
except KeyError:
group = layout.groups[self.owner] = \
TextLayoutTextureGroup(self.owner, layout.foreground_group)
n_glyphs = self.length
vertices = []
tex_coords = []
x1 = x
for start, end, baseline in context.baseline_iter.ranges(i, i+n_glyphs):
baseline = layout._parse_distance(baseline)
assert len(self.glyphs[start - i:end - i]) == end - start
for kern, glyph in self.glyphs[start - i:end - i]:
x1 += kern
v0, v1, v2, v3 = glyph.vertices
v0 += x1
v2 += x1
v1 += y + baseline
v3 += y + baseline
vertices.extend(map(int, [v0, v1, v2, v1, v2, v3, v0, v3]))
t = glyph.tex_coords
tex_coords.extend(t)
x1 += glyph.advance
# Text color
colors = []
for start, end, color in context.colors_iter.ranges(i, i+n_glyphs):
if color is None:
color = (0, 0, 0, 255)
colors.extend(color * ((end - start) * 4))
vertex_list = layout.batch.add(n_glyphs * 4, GL_QUADS, group,
('v2f/dynamic', vertices),
('t3f/dynamic', tex_coords),
('c4B/dynamic', colors))
context.add_list(vertex_list)
# Decoration (background color and underline)
#
# Should iterate over baseline too, but in practice any sensible
# change in baseline will correspond with a change in font size,
# and thus glyph run as well. So we cheat and just use whatever
# baseline was seen last.
background_vertices = []
background_colors = []
underline_vertices = []
underline_colors = []
y1 = y + self.descent + baseline
y2 = y + self.ascent + baseline
x1 = x
for start, end, decoration in \
context.decoration_iter.ranges(i, i+n_glyphs):
bg, underline = decoration
x2 = x1
for kern, glyph in self.glyphs[start - i:end - i]:
x2 += glyph.advance + kern
if bg is not None:
background_vertices.extend(
[x1, y1, x2, y1, x2, y2, x1, y2])
background_colors.extend(bg * 4)
if underline is not None:
underline_vertices.extend(
[x1, y + baseline - 2, x2, y + baseline - 2])
underline_colors.extend(underline * 2)
x1 = x2
if background_vertices:
background_list = layout.batch.add(
len(background_vertices) // 2, GL_QUADS,
layout.background_group,
('v2f/dynamic', background_vertices),
('c4B/dynamic', background_colors))
context.add_list(background_list)
if underline_vertices:
underline_list = layout.batch.add(
len(underline_vertices) // 2, GL_LINES,
layout.foreground_decoration_group,
('v2f/dynamic', underline_vertices),
('c4B/dynamic', underline_colors))
context.add_list(underline_list)
def delete(self, layout):
pass
def get_point_in_box(self, position):
x = 0
for (kern, glyph) in self.glyphs:
if position == 0:
break
position -= 1
x += glyph.advance + kern
return x
def get_position_in_box(self, x):
position = 0
last_glyph_x = 0
for kern, glyph in self.glyphs:
last_glyph_x += kern
if last_glyph_x + glyph.advance / 2 > x:
return position
position += 1
last_glyph_x += glyph.advance
return position
def __repr__(self):
return '_GlyphBox(%r)' % self.glyphs
class _InlineElementBox(_AbstractBox):
def __init__(self, element):
'''Create a glyph run holding a single element.
'''
super(_InlineElementBox, self).__init__(
element.ascent, element.descent, element.advance, 1)
self.element = element
self.placed = False
def place(self, layout, i, x, y, context):
self.element.place(layout, x, y)
self.placed = True
context.add_box(self)
def delete(self, layout):
# font == element
if self.placed:
self.element.remove(layout)
self.placed = False
def get_point_in_box(self, position):
if position == 0:
return 0
else:
return self.advance
def get_position_in_box(self, x):
if x < self.advance / 2:
return 0
else:
return 1
def __repr__(self):
return '_InlineElementBox(%r)' % self.element
class _InvalidRange(object):
def __init__(self):
self.start = sys.maxint
self.end = 0
def insert(self, start, length):
if self.start >= start:
self.start += length
if self.end >= start:
self.end += length
self.invalidate(start, start + length)
def delete(self, start, end):
if self.start > end:
self.start -= end - start
elif self.start > start:
self.start = start
if self.end > end:
self.end -= end - start
elif self.end > start:
self.end = start
def invalidate(self, start, end):
if end <= start:
return
self.start = min(self.start, start)
self.end = max(self.end, end)
def validate(self):
start, end = self.start, self.end
self.start = sys.maxint
self.end = 0
return start, end
def is_invalid(self):
return self.end > self.start
# Text group hierarchy
#
# top_group [Scrollable]TextLayoutGroup(Group)
# background_group OrderedGroup(0)
# foreground_group TextLayoutForegroundGroup(OrderedGroup(1))
# [font textures] TextLayoutTextureGroup(Group)
# [...] TextLayoutTextureGroup(Group)
# foreground_decoration_group
# TextLayoutForegroundDecorationGroup(OrderedGroup(2))
class TextLayoutGroup(graphics.Group):
'''Top-level rendering group for `TextLayout`.
The blend function is set for glyph rendering (``GL_SRC_ALPHA`` /
``GL_ONE_MINUS_SRC_ALPHA``). The group is shared by all `TextLayout`
instances as it has no internal state.
'''
def set_state(self):
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self):
glPopAttrib()
class ScrollableTextLayoutGroup(graphics.Group):
'''Top-level rendering group for `ScrollableTextLayout`.
The group maintains internal state for setting the clipping planes and
view transform for scrolling. Because the group has internal state
specific to the text layout, the group is never shared.
'''
_clip_x = 0
_clip_y = 0
_clip_width = 0
_clip_height = 0
_view_x = 0
_view_y = 0
translate_x = 0 # x - view_x
translate_y = 0 # y - view_y
def set_state(self):
glPushAttrib(GL_ENABLE_BIT | GL_TRANSFORM_BIT | GL_CURRENT_BIT)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
# Disable clipping planes to check culling.
glEnable(GL_CLIP_PLANE0)
glEnable(GL_CLIP_PLANE1)
glEnable(GL_CLIP_PLANE2)
glEnable(GL_CLIP_PLANE3)
# Left
glClipPlane(GL_CLIP_PLANE0, (GLdouble * 4)(
1, 0, 0, -(self._clip_x - 1)))
# Top
glClipPlane(GL_CLIP_PLANE1, (GLdouble * 4)(
0, -1, 0, self._clip_y))
# Right
glClipPlane(GL_CLIP_PLANE2, (GLdouble * 4)(
-1, 0, 0, self._clip_x + self._clip_width + 1))
# Bottom
glClipPlane(GL_CLIP_PLANE3, (GLdouble * 4)(
0, 1, 0, -(self._clip_y - self._clip_height)))
glTranslatef(self.translate_x, self.translate_y, 0)
def unset_state(self):
glTranslatef(-self.translate_x, -self.translate_y, 0)
glPopAttrib()
def _set_top(self, top):
self._clip_y = top
self.translate_y = self._clip_y - self._view_y
top = property(lambda self: self._clip_y, _set_top,
doc='''Top edge of the text layout (measured from the
bottom of the graphics viewport).
:type: int
''')
def _set_left(self, left):
self._clip_x = left
self.translate_x = self._clip_x - self._view_x
left = property(lambda self: self._clip_x, _set_left,
doc='''Left edge of the text layout.
:type: int
''')
def _set_width(self, width):
self._clip_width = width
width = property(lambda self: self._clip_width, _set_width,
doc='''Width of the text layout.
:type: int
''')
def _set_height(self, height):
self._clip_height = height
height = property(lambda self: self._height, _set_height,
doc='''Height of the text layout.
:type: int
''')
def _set_view_x(self, view_x):
self._view_x = view_x
self.translate_x = self._clip_x - self._view_x
view_x = property(lambda self: self._view_x, _set_view_x,
doc='''Horizontal scroll offset.
:type: int
''')
def _set_view_y(self, view_y):
self._view_y = view_y
self.translate_y = self._clip_y - self._view_y
view_y = property(lambda self: self._view_y, _set_view_y,
doc='''Vertical scroll offset.
:type: int
''')
def __eq__(self, other):
return self is other
def __hash__(self):
return id(self)
class TextLayoutForegroundGroup(graphics.OrderedGroup):
'''Rendering group for foreground elements (glyphs) in all text layouts.
The group enables ``GL_TEXTURE_2D``.
'''
def set_state(self):
glEnable(GL_TEXTURE_2D)
# unset_state not needed, as parent group will pop enable bit
class TextLayoutForegroundDecorationGroup(graphics.OrderedGroup):
'''Rendering group for decorative elements (e.g., glyph underlines) in all
text layouts.
The group disables ``GL_TEXTURE_2D``.
'''
def set_state(self):
glDisable(GL_TEXTURE_2D)
# unset_state not needed, as parent group will pop enable bit
class TextLayoutTextureGroup(graphics.Group):
'''Rendering group for a glyph texture in all text layouts.
The group binds its texture to ``GL_TEXTURE_2D``. The group is shared
between all other text layout uses of the same texture.
'''
def __init__(self, texture, parent):
assert texture.target == GL_TEXTURE_2D
super(TextLayoutTextureGroup, self).__init__(parent)
self.texture = texture
def set_state(self):
glBindTexture(GL_TEXTURE_2D, self.texture.id)
# unset_state not needed, as next group will either bind a new texture or
# pop enable bit.
def __hash__(self):
return hash((self.texture.id, self.parent))
def __eq__(self, other):
return (self.__class__ is other.__class__ and
self.texture.id == other.texture.id and
self.parent is other.parent)
def __repr__(self):
return '%s(%d, %r)' % (self.__class__.__name__,
self.texture.id,
self.parent)
class TextLayout(object):
'''Lay out and display documents.
This class is intended for displaying documents that do not change
regularly -- any change will cost some time to lay out the complete
document again and regenerate all vertex lists.
The benefit of this class is that texture state is shared between
all layouts of this class. The time to draw one `TextLayout` may be
roughly the same as the time to draw one `IncrementalTextLayout`; but
drawing ten `TextLayout` objects in one batch is much faster than drawing
ten incremental or scrollable text layouts.
`Label` and `HTMLLabel` provide a convenient interface to this class.
:Ivariables:
`content_width` : int
Calculated width of the text in the layout. This may overflow
the desired width if word-wrapping failed.
`content_height` : int
Calculated height of the text in the layout.
`top_group` : `Group`
Top-level rendering group.
`background_group` : `Group`
Rendering group for background color.
`foreground_group` : `Group`
Rendering group for glyphs.
`foreground_decoration_group` : `Group`
Rendering group for glyph underlines.
'''
_document = None
_vertex_lists = ()
_boxes = ()
top_group = TextLayoutGroup()
background_group = graphics.OrderedGroup(0, top_group)
foreground_group = TextLayoutForegroundGroup(1, top_group)
foreground_decoration_group = \
TextLayoutForegroundDecorationGroup(2, top_group)
_update_enabled = True
_own_batch = False
_origin_layout = False # Lay out relative to origin? Otherwise to box.
def __init__(self, document, width=None, height=None,
multiline=False, dpi=None, batch=None, group=None,
wrap_lines=True):
'''Create a text layout.
:Parameters:
`document` : `AbstractDocument`
Document to display.
`width` : int
Width of the layout in pixels, or None
`height` : int
Height of the layout in pixels, or None
`multiline` : bool
If False, newline and paragraph characters are ignored, and
text is not word-wrapped.
If True, text is wrapped only if the `wrap_lines` is True.
`dpi` : float
Font resolution; defaults to 96.
`batch` : `Batch`
Optional graphics batch to add this layout to.
`group` : `Group`
Optional rendering group to parent all groups this text layout
uses. Note that layouts with different
rendered simultaneously in a batch.
`wrap_lines` : bool
If True and `multiline` is True, the text is word-wrapped using
the specified width.
'''
self.content_width = 0
self.content_height = 0
self.groups = {}
self._init_groups(group)
if batch is None:
batch = graphics.Batch()
self._own_batch = True
self.batch = batch
self._width = width
if height is not None:
self._height = height
if multiline:
self._multiline = multiline
self._wrap_lines_flag = wrap_lines
self._wrap_lines_invariant()
if dpi is None:
dpi = 96
self._dpi = dpi
self.document = document
def _wrap_lines_invariant(self):
self._wrap_lines = self._multiline and self._wrap_lines_flag
assert not self._wrap_lines or self._width, "When the parameters "\
"'multiline' and 'wrap_lines' are True, the parameter 'width'"\
"must be a number."
def _parse_distance(self, distance):
if distance is None:
return None
return _parse_distance(distance, self._dpi)
def begin_update(self):
'''Indicate that a number of changes to the layout or document
are about to occur.
Changes to the layout or document between calls to `begin_update` and
`end_update` do not trigger any costly relayout of text. Relayout of
all changes is performed when `end_update` is called.
Note that between the `begin_update` and `end_update` calls, values
such as `content_width` and `content_height` are undefined (i.e., they
may or may not be updated to reflect the latest changes).
'''
self._update_enabled = False
def end_update(self):
'''Perform pending layout changes since `begin_update`.
See `begin_update`.
'''
self._update_enabled = True
self._update()
dpi = property(lambda self: self._dpi,
doc='''Get DPI used by this layout.
Read-only.
:type: float
''')
def delete(self):
'''Remove this layout from its batch.
'''
for vertex_list in self._vertex_lists:
vertex_list.delete()
self._vertex_lists = []
for box in self._boxes:
box.delete(self)
def draw(self):
'''Draw this text layout.
Note that this method performs very badly if a batch was supplied to
the constructor. If you add this layout to a batch, you should
ideally use only the batch's draw method.
'''
if self._own_batch:
self.batch.draw()
else:
self.batch.draw_subset(self._vertex_lists)
def _init_groups(self, group):
if group:
self.top_group = TextLayoutGroup(group)
self.background_group = graphics.OrderedGroup(0, self.top_group)
self.foreground_group = TextLayoutForegroundGroup(1, self.top_group)
self.foreground_decoration_group = \
TextLayoutForegroundDecorationGroup(2, self.top_group)
# Otherwise class groups are (re)used.
def _get_document(self):
return self._document
def _set_document(self, document):
if self._document:
self._document.remove_handlers(self)
self._uninit_document()
document.push_handlers(self)
self._document = document
self._init_document()
document = property(_get_document, _set_document,
'''Document to display.
For `IncrementalTextLayout` it is far more efficient to modify a document
in-place than to replace the document instance on the layout.
:type: `AbstractDocument`
''')
def _get_lines(self):
len_text = len(self._document.text)
glyphs = self._get_glyphs()
owner_runs = runlist.RunList(len_text, None)
self._get_owner_runs(owner_runs, glyphs, 0, len_text)
lines = [line for line in self._flow_glyphs(glyphs, owner_runs,
0, len_text)]
self.content_width = 0
self._flow_lines(lines, 0, len(lines))
return lines
def _update(self):
if not self._update_enabled:
return
for _vertex_list in self._vertex_lists:
_vertex_list.delete()
for box in self._boxes:
box.delete(self)
self._vertex_lists = []
self._boxes = []
self.groups.clear()
if not self._document or not self._document.text:
return
lines = self._get_lines()
colors_iter = self._document.get_style_runs('color')
background_iter = self._document.get_style_runs('background_color')
if self._origin_layout:
left = top = 0
else:
left = self._get_left()
top = self._get_top(lines)
context = _StaticLayoutContext(self, self._document,
colors_iter, background_iter)
for line in lines:
self._create_vertex_lists(left + line.x, top + line.y,
line.start, line.boxes, context)
def _get_left(self):
if self._multiline:
width = self._width if self._wrap_lines else self.content_width
else:
width = self.content_width
if self._anchor_x == 'left':
return self._x
elif self._anchor_x == 'center':
return self._x - width // 2
elif self._anchor_x == 'right':
return self._x - width
else:
assert False, 'Invalid anchor_x'
def _get_top(self, lines):
if self._height is None:
height = self.content_height
offset = 0
else:
height = self._height
if self._content_valign == 'top':
offset = 0
elif self._content_valign == 'bottom':
offset = max(0, self._height - self.content_height)
elif self._content_valign == 'center':
offset = max(0, self._height - self.content_height) // 2
else:
assert False, 'Invalid content_valign'
if self._anchor_y == 'top':
return self._y - offset
elif self._anchor_y == 'baseline':
return self._y + lines[0].ascent - offset
elif self._anchor_y == 'bottom':
return self._y + height - offset
elif self._anchor_y == 'center':
if len(lines) == 1 and self._height is None:
# This "looks" more centered than considering all of the
# descent.
line = lines[0]
return self._y + line.ascent // 2 - line.descent // 4
else:
return self._y + height // 2 - offset
else:
assert False, 'Invalid anchor_y'
def _init_document(self):
self._update()
def _uninit_document(self):
pass
def on_insert_text(self, start, text):
'''Event handler for `AbstractDocument.on_insert_text`.
The event handler is bound by the text layout; there is no need for
applications to interact with this method.
'''
self._init_document()
def on_delete_text(self, start, end):
'''Event handler for `AbstractDocument.on_delete_text`.
The event handler is bound by the text layout; there is no need for
applications to interact with this method.
'''
self._init_document()
def on_style_text(self, start, end, attributes):
'''Event handler for `AbstractDocument.on_style_text`.
The event handler is bound by the text layout; there is no need for
applications to interact with this method.
'''
self._init_document()
def _get_glyphs(self):
glyphs = []
runs = runlist.ZipRunIterator((
self._document.get_font_runs(dpi=self._dpi),
self._document.get_element_runs()))
text = self._document.text
for start, end, (font, element) in runs.ranges(0, len(text)):
if element:
glyphs.append(_InlineElementBox(element))
else:
glyphs.extend(font.get_glyphs(text[start:end]))
return glyphs
def _get_owner_runs(self, owner_runs, glyphs, start, end):
owner = glyphs[start].owner
run_start = start
# TODO avoid glyph slice on non-incremental
for i, glyph in enumerate(glyphs[start:end]):
if owner != glyph.owner:
owner_runs.set_run(run_start, i + start, owner)
owner = glyph.owner
run_start = i + start
owner_runs.set_run(run_start, end, owner)
def _flow_glyphs(self, glyphs, owner_runs, start, end):
# TODO change flow generator on self, avoiding this conditional.
if not self._multiline:
for line in self._flow_glyphs_single_line(glyphs, owner_runs,
start, end):
yield line
else:
for line in self._flow_glyphs_wrap(glyphs, owner_runs, start, end):
yield line
def _flow_glyphs_wrap(self, glyphs, owner_runs, start, end):
'''Word-wrap styled text into lines of fixed width.
Fits `glyphs` in range `start` to `end` into `_Line` s which are
then yielded.
'''
owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
font_iterator = self._document.get_font_runs(dpi=self._dpi)
align_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('align'),
lambda value: value in ('left', 'right', 'center'),
'left')
if self._width is None:
wrap_iterator = runlist.ConstRunIterator(
len(self.document.text), False)
else:
wrap_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('wrap'),
lambda value: value in (True, False, 'char', 'word'),
True)
margin_left_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('margin_left'),
lambda value: value is not None, 0)
margin_right_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('margin_right'),
lambda value: value is not None, 0)
indent_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('indent'),
lambda value: value is not None, 0)
kerning_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('kerning'),
lambda value: value is not None, 0)
tab_stops_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('tab_stops'),
lambda value: value is not None, [])
line = _Line(start)
line.align = align_iterator[start]
line.margin_left = self._parse_distance(margin_left_iterator[start])
line.margin_right = self._parse_distance(margin_right_iterator[start])
if start == 0 or self.document.text[start - 1] in u'\n\u2029':
line.paragraph_begin = True
line.margin_left += self._parse_distance(indent_iterator[start])
wrap = wrap_iterator[start]
if self._wrap_lines:
width = self._width - line.margin_left - line.margin_right
# Current right-most x position in line being laid out.
x = 0
# Boxes accumulated but not yet committed to a line.
run_accum = []
run_accum_width = 0
# Amount of whitespace accumulated at end of line
eol_ws = 0
# Iterate over glyph owners (texture states); these form GlyphBoxes,
# but broken into lines.
font = None
for start, end, owner in owner_iterator:
font = font_iterator[start]
# Glyphs accumulated in this owner but not yet committed to a
# line.
owner_accum = []
owner_accum_width = 0
# Glyphs accumulated in this owner AND also committed to the
# current line (some whitespace has followed all of the committed
# glyphs).
owner_accum_commit = []
owner_accum_commit_width = 0
# Ignore kerning of first glyph on each line
nokern = True
# Current glyph index
index = start
# Iterate over glyphs in this owner run. `text` is the
# corresponding character data for the glyph, and is used to find
# whitespace and newlines.
for (text, glyph) in zip(self.document.text[start:end],
glyphs[start:end]):
if nokern:
kern = 0
nokern = False
else:
kern = self._parse_distance(kerning_iterator[index])
if wrap != 'char' and text in u'\u0020\u200b\t':
# Whitespace: commit pending runs to this line.
for run in run_accum:
line.add_box(run)
run_accum = []
run_accum_width = 0
if text == '\t':
# Fix up kern for this glyph to align to the next tab
# stop
for tab_stop in tab_stops_iterator[index]:
tab_stop = self._parse_distance(tab_stop)
if tab_stop > x + line.margin_left:
break
else:
# No more tab stops, tab to 100 pixels
tab = 50.
tab_stop = \
(((x + line.margin_left) // tab) + 1) * tab
kern = int(tab_stop - x - line.margin_left -
glyph.advance)
owner_accum.append((kern, glyph))
owner_accum_commit.extend(owner_accum)
owner_accum_commit_width += owner_accum_width + \
glyph.advance + kern
eol_ws += glyph.advance + kern
owner_accum = []
owner_accum_width = 0
x += glyph.advance + kern
index += 1
# The index at which the next line will begin (the
# current index, because this is the current best
# breakpoint).
next_start = index
else:
new_paragraph = text in u'\n\u2029'
new_line = (text == u'\u2028') or new_paragraph
if (wrap and self._wrap_lines and x + kern + glyph.advance >= width) or new_line:
# Either the pending runs have overflowed the allowed
# line width or a newline was encountered. Either
# way, the current line must be flushed.
if new_line or wrap == 'char':
# Forced newline or char-level wrapping. Commit
# everything pending without exception.
for run in run_accum:
line.add_box(run)
run_accum = []
run_accum_width = 0
owner_accum_commit.extend(owner_accum)
owner_accum_commit_width += owner_accum_width
owner_accum = []
owner_accum_width = 0
line.length += 1
next_start = index
if new_line:
next_start += 1
# Create the _GlyphBox for the committed glyphs in the
# current owner.
if owner_accum_commit:
line.add_box(
_GlyphBox(owner, font, owner_accum_commit,
owner_accum_commit_width))
owner_accum_commit = []
owner_accum_commit_width = 0
if new_line and not line.boxes:
# Empty line: give it the current font's default
# line-height.
line.ascent = font.ascent
line.descent = font.descent
# Flush the line, unless nothing got committed, in
# which case it's a really long string of glyphs
# without any breakpoints (in which case it will be
# flushed at the earliest breakpoint, not before
# something is committed).
if line.boxes or new_line:
# Trim line width of whitespace on right-side.
line.width -= eol_ws
if new_paragraph:
line.paragraph_end = True
yield line
line = _Line(next_start)
line.align = align_iterator[next_start]
line.margin_left = self._parse_distance(
margin_left_iterator[next_start])
line.margin_right = self._parse_distance(
margin_right_iterator[next_start])
if new_paragraph:
line.paragraph_begin = True
# Remove kern from first glyph of line
if run_accum:
k, g = run_accum[0].glyphs[0]
run_accum[0].glyphs[0] = (0, g)
run_accum_width -= k
elif owner_accum:
k, g = owner_accum[0]
owner_accum[0] = (0, g)
owner_accum_width -= k
else:
nokern = True
x = run_accum_width + owner_accum_width
if self._wrap_lines:
width = (self._width -
line.margin_left - line.margin_right)
if isinstance(glyph, _AbstractBox):
# Glyph is already in a box. XXX Ignore kern?
run_accum.append(glyph)
run_accum_width += glyph.advance
x += glyph.advance
elif new_paragraph:
# New paragraph started, update wrap style
wrap = wrap_iterator[next_start]
line.margin_left += \
self._parse_distance(indent_iterator[next_start])
if self._wrap_lines:
width = (self._width -
line.margin_left - line.margin_right)
elif not new_line:
# If the glyph was any non-whitespace, non-newline
# character, add it to the pending run.
owner_accum.append((kern, glyph))
owner_accum_width += glyph.advance + kern
x += glyph.advance + kern
index += 1
eol_ws = 0
# The owner run is finished; create GlyphBoxes for the committed
# and pending glyphs.
if owner_accum_commit:
line.add_box(_GlyphBox(owner, font, owner_accum_commit,
owner_accum_commit_width))
if owner_accum:
run_accum.append(_GlyphBox(owner, font, owner_accum,
owner_accum_width))
run_accum_width += owner_accum_width
# All glyphs have been processed: commit everything pending and flush
# the final line.
for run in run_accum:
line.add_box(run)
if not line.boxes:
# Empty line gets font's line-height
if font is None:
font = self._document.get_font(0, dpi=self._dpi)
line.ascent = font.ascent
line.descent = font.descent
yield line
def _flow_glyphs_single_line(self, glyphs, owner_runs, start, end):
owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
font_iterator = self.document.get_font_runs(dpi=self._dpi)
kern_iterator = runlist.FilteredRunIterator(
self.document.get_style_runs('kerning'),
lambda value: value is not None, 0)
line = _Line(start)
font = font_iterator[0]
for start, end, owner in owner_iterator:
font = font_iterator[start]
width = 0
owner_glyphs = []
for kern_start, kern_end, kern in kern_iterator.ranges(start, end):
gs = glyphs[kern_start:kern_end]
width += sum([g.advance for g in gs])
width += kern * (kern_end - kern_start)
owner_glyphs.extend(zip([kern] * (kern_end - kern_start), gs))
if owner is None:
# Assume glyphs are already boxes.
for kern, glyph in owner_glyphs:
line.add_box(glyph)
else:
line.add_box(_GlyphBox(owner, font, owner_glyphs, width))
if not line.boxes:
line.ascent = font.ascent
line.descent = font.descent
line.paragraph_begin = line.paragraph_end = True
yield line
def _flow_lines(self, lines, start, end):
margin_top_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('margin_top'),
lambda value: value is not None, 0)
margin_bottom_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('margin_bottom'),
lambda value: value is not None, 0)
line_spacing_iterator = self._document.get_style_runs('line_spacing')
leading_iterator = runlist.FilteredRunIterator(
self._document.get_style_runs('leading'),
lambda value: value is not None, 0)
if start == 0:
y = 0
else:
line = lines[start - 1]
line_spacing = \
self._parse_distance(line_spacing_iterator[line.start])
leading = \
self._parse_distance(leading_iterator[line.start])
y = line.y
if line_spacing is None:
y += line.descent
if line.paragraph_end:
y -= self._parse_distance(margin_bottom_iterator[line.start])
line_index = start
for line in lines[start:]:
if line.paragraph_begin:
y -= self._parse_distance(margin_top_iterator[line.start])
line_spacing = \
self._parse_distance(line_spacing_iterator[line.start])
leading = self._parse_distance(leading_iterator[line.start])
else:
y -= leading
if line_spacing is None:
y -= line.ascent
else:
y -= line_spacing
if line.align == 'left' or line.width > self.width:
line.x = line.margin_left
elif line.align == 'center':
line.x = (self.width - line.margin_left - line.margin_right
- line.width) // 2 + line.margin_left
elif line.align == 'right':
line.x = self.width - line.margin_right - line.width
self.content_width = max(self.content_width,
line.width + line.margin_left)
if line.y == y and line_index >= end:
# Early exit: all invalidated lines have been reflowed and the
# next line has no change (therefore subsequent lines do not
# need to be changed).
break
line.y = y
if line_spacing is None:
y += line.descent
if line.paragraph_end:
y -= self._parse_distance(margin_bottom_iterator[line.start])
line_index += 1
else:
self.content_height = -y
return line_index
def _create_vertex_lists(self, x, y, i, boxes, context):
for box in boxes:
box.place(self, i, x, y, context)
x += box.advance
i += box.length
_x = 0
def _set_x(self, x):
if self._boxes:
self._x = x
self._update()
else:
dx = x - self._x
l_dx = lambda x: int(x + dx)
for vertex_list in self._vertex_lists:
vertices = vertex_list.vertices[:]
vertices[::2] = map(l_dx, vertices[::2])
vertex_list.vertices[:] = vertices
self._x = x
def _get_x(self):
return self._x
x = property(_get_x, _set_x,
doc='''X coordinate of the layout.
See also `anchor_x`.
:type: int
''')
_y = 0
def _set_y(self, y):
if self._boxes:
self._y = y
self._update()
else:
dy = y - self._y
l_dy = lambda y: int(y + dy)
for vertex_list in self._vertex_lists:
vertices = vertex_list.vertices[:]
vertices[1::2] = map(l_dy, vertices[1::2])
vertex_list.vertices[:] = vertices
self._y = y
def _get_y(self):
return self._y
y = property(_get_y, _set_y,
doc='''Y coordinate of the layout.
See also `anchor_y`.
:type: int
''')
_width = None
def _set_width(self, width):
self._width = width
self._wrap_lines_invariant()
self._update()
def _get_width(self):
return self._width
width = property(_get_width, _set_width,
doc='''Width of the layout.
This property has no effect if `multiline` is False or `wrap_lines` is False.
:type: int
''')
_height = None
def _set_height(self, height):
self._height = height
self._update()
def _get_height(self):
return self._height
height = property(_get_height, _set_height,
doc='''Height of the layout.
:type: int
''')
_multiline = False
def _set_multiline(self, multiline):
self._multiline = multiline
self._wrap_lines_invariant()
self._update()
def _get_multiline(self):
return self._multiline
multiline = property(_get_multiline, _set_multiline,
doc='''Set if multiline layout is enabled.
If multiline is False, newline and paragraph characters are ignored and
text is not word-wrapped.
If True, the text is word-wrapped only if the `wrap_lines` is True.
:type: bool
''')
_anchor_x = 'left'
def _set_anchor_x(self, anchor_x):
self._anchor_x = anchor_x
self._update()
def _get_anchor_x(self):
return self._anchor_x
anchor_x = property(_get_anchor_x, _set_anchor_x,
doc='''Horizontal anchor alignment.
This property determines the meaning of the `x` coordinate. It is one of
the enumerants:
``"left"`` (default)
The X coordinate gives the position of the left edge of the layout.
``"center"``
The X coordinate gives the position of the center of the layout.
``"right"``
The X coordinate gives the position of the right edge of the layout.
For the purposes of calculating the position resulting from this
alignment, the width of the layout is taken to be `width` if `multiline`
is True and `wrap_lines` is True, otherwise `content_width`.
:type: str
''')
_anchor_y = 'bottom'
def _set_anchor_y(self, anchor_y):
self._anchor_y = anchor_y
self._update()
def _get_anchor_y(self):
return self._anchor_y
anchor_y = property(_get_anchor_y, _set_anchor_y,
doc='''Vertical anchor alignment.
This property determines the meaning of the `y` coordinate. It is one of
the enumerants:
``"top"``
The Y coordinate gives the position of the top edge of the layout.
``"center"``
The Y coordinate gives the position of the center of the layout.
``"baseline"``
The Y coordinate gives the position of the baseline of the first
line of text in the layout.
``"bottom"`` (default)
The Y coordinate gives the position of the bottom edge of the layout.
For the purposes of calculating the position resulting from this
alignment, the height of the layout is taken to be the smaller of
`height` and `content_height`.
See also `content_valign`.
:type: str
''')
_content_valign = 'top'
def _set_content_valign(self, content_valign):
self._content_valign = content_valign
self._update()
def _get_content_valign(self):
return self._content_valign
content_valign = property(_get_content_valign, _set_content_valign,
doc='''Vertical alignment of content within
larger layout box.
This property determines how content is positioned within the layout
box when ``content_height`` is less than ``height``. It is one
of the enumerants:
``top`` (default)
Content is aligned to the top of the layout box.
``center``
Content is centered vertically within the layout box.
``bottom``
Content is aligned to the bottom of the layout box.
This property has no effect when ``content_height`` is greater
than ``height`` (in which case the content is aligned to the top) or when
``height`` is ``None`` (in which case there is no vertical layout box
dimension).
:type: str
''')
class ScrollableTextLayout(TextLayout):
'''Display text in a scrollable viewport.
This class does not display a scrollbar or handle scroll events; it merely
clips the text that would be drawn in `TextLayout` to the bounds of the
layout given by `x`, `y`, `width` and `height`; and offsets the text by a
scroll offset.
Use `view_x` and `view_y` to scroll the text within the viewport.
'''
_origin_layout = True
def __init__(self, document, width, height, multiline=False, dpi=None,
batch=None, group=None, wrap_lines=True):
super(ScrollableTextLayout, self).__init__(
document, width, height, multiline, dpi, batch, group, wrap_lines)
self.top_group.width = self._width
self.top_group.height = self._height
def _init_groups(self, group):
# Scrollable layout never shares group becauase of translation.
self.top_group = ScrollableTextLayoutGroup(group)
self.background_group = graphics.OrderedGroup(0, self.top_group)
self.foreground_group = TextLayoutForegroundGroup(1, self.top_group)
self.foreground_decoration_group = \
TextLayoutForegroundDecorationGroup(2, self.top_group)
def _set_x(self, x):
self._x = x
self.top_group.left = self._get_left()
def _get_x(self):
return self._x
x = property(_get_x, _set_x)
def _set_y(self, y):
self._y = y
self.top_group.top = self._get_top(self._get_lines())
def _get_y(self):
return self._y
y = property(_get_y, _set_y)
def _set_width(self, width):
super(ScrollableTextLayout, self)._set_width(width)
self.top_group.left = self._get_left()
self.top_group.width = self._width
def _get_width(self):
return self._width
width = property(_get_width, _set_width)
def _set_height(self, height):
super(ScrollableTextLayout, self)._set_height(height)
self.top_group.top = self._get_top(self._get_lines())
self.top_group.height = self._height
def _get_height(self):
return self._height
height = property(_get_height, _set_height)
def _set_anchor_x(self, anchor_x):
self._anchor_x = anchor_x
self.top_group.left = self._get_left()
def _get_anchor_x(self):
return self._anchor_x
anchor_x = property(_get_anchor_x, _set_anchor_x)
def _set_anchor_y(self, anchor_y):
self._anchor_y = anchor_y
self.top_group.top = self._get_top(self._get_lines())
def _get_anchor_y(self):
return self._anchor_y
anchor_y = property(_get_anchor_y, _set_anchor_y)
# Offset of content within viewport
def _set_view_x(self, view_x):
view_x = max(0, min(self.content_width - self.width, view_x))
self.top_group.view_x = view_x
def _get_view_x(self):
return self.top_group.view_x
view_x = property(_get_view_x, _set_view_x,
doc='''Horizontal scroll offset.
The initial value is 0, and the left edge of the text will touch the left
side of the layout bounds. A positive value causes the text to "scroll"
to the right. Values are automatically clipped into the range
``[0, content_width - width]``
:type: int
''')
def _set_view_y(self, view_y):
# view_y must be negative.
view_y = min(0, max(self.height - self.content_height, view_y))
self.top_group.view_y = view_y
def _get_view_y(self):
return self.top_group.view_y
view_y = property(_get_view_y, _set_view_y,
doc='''Vertical scroll offset.
The initial value is 0, and the top of the text will touch the top of the
layout bounds (unless the content height is less than the layout height,
in which case `content_valign` is used).
A negative value causes the text to "scroll" upwards. Values outside of
the range ``[height - content_height, 0]`` are automatically clipped in
range.
:type: int
''')
class IncrementalTextLayout(ScrollableTextLayout, event.EventDispatcher):
'''Displayed text suitable for interactive editing and/or scrolling
large documents.
Unlike `TextLayout` and `ScrollableTextLayout`, this class generates
vertex lists only for lines of text that are visible. As the document is
scrolled, vertex lists are deleted and created as appropriate to keep
video memory usage to a minimum and improve rendering speed.
Changes to the document are quickly reflected in this layout, as only the
affected line(s) are reflowed. Use `begin_update` and `end_update` to
further reduce the amount of processing required.
The layout can also display a text selection (text with a different
background color). The `Caret` class implements a visible text cursor and
provides event handlers for scrolling, selecting and editing text in an
incremental text layout.
'''
_selection_start = 0
_selection_end = 0
_selection_color = [255, 255, 255, 255]
_selection_background_color = [46, 106, 197, 255]
def __init__(self, document, width, height, multiline=False, dpi=None,
batch=None, group=None, wrap_lines=True):
event.EventDispatcher.__init__(self)
self.glyphs = []
self.lines = []
self.invalid_glyphs = _InvalidRange()
self.invalid_flow = _InvalidRange()
self.invalid_lines = _InvalidRange()
self.invalid_style = _InvalidRange()
self.invalid_vertex_lines = _InvalidRange()
self.visible_lines = _InvalidRange()
self.owner_runs = runlist.RunList(0, None)
ScrollableTextLayout.__init__(self,
document, width, height, multiline, dpi, batch, group, wrap_lines)
self.top_group.width = width
self.top_group.left = self._get_left()
self.top_group.height = height
self.top_group.top = self._get_top(self._get_lines())
def _init_document(self):
assert self._document, \
'Cannot remove document from IncrementalTextLayout'
self.on_insert_text(0, self._document.text)
def _uninit_document(self):
self.on_delete_text(0, len(self._document.text))
def _get_lines(self):
return self.lines
def delete(self):
for line in self.lines:
line.delete(self)
self.batch = None
if self._document:
self._document.remove_handlers(self)
self._document = None
def on_insert_text(self, start, text):
len_text = len(text)
self.glyphs[start:start] = [None] * len_text
self.invalid_glyphs.insert(start, len_text)
self.invalid_flow.insert(start, len_text)
self.invalid_style.insert(start, len_text)
self.owner_runs.insert(start, len_text)
for line in self.lines:
if line.start >= start:
line.start += len_text
self._update()
def on_delete_text(self, start, end):
self.glyphs[start:end] = []
self.invalid_glyphs.delete(start, end)
self.invalid_flow.delete(start, end)
self.invalid_style.delete(start, end)
self.owner_runs.delete(start, end)
size = end - start
for line in self.lines:
if line.start > start:
line.start = max(line.start - size, start)
if start == 0:
self.invalid_flow.invalidate(0, 1)
else:
self.invalid_flow.invalidate(start - 1, start)
self._update()
def on_style_text(self, start, end, attributes):
if ('font_name' in attributes or
'font_size' in attributes or
'bold' in attributes or
'italic' in attributes):
self.invalid_glyphs.invalidate(start, end)
elif False: # Attributes that change flow
self.invalid_flow.invalidate(start, end)
elif ('color' in attributes or
'background_color' in attributes):
self.invalid_style.invalidate(start, end)
self._update()
def _update(self):
if not self._update_enabled:
return
trigger_update_event = (self.invalid_glyphs.is_invalid() or
self.invalid_flow.is_invalid() or
self.invalid_lines.is_invalid())
# Special care if there is no text:
if not self.glyphs:
for line in self.lines:
line.delete(self)
del self.lines[:]
self.lines.append(_Line(0))
font = self.document.get_font(0, dpi=self._dpi)
self.lines[0].ascent = font.ascent
self.lines[0].descent = font.descent
self.lines[0].paragraph_begin = self.lines[0].paragraph_end = True
self.invalid_lines.invalidate(0, 1)
self._update_glyphs()
self._update_flow_glyphs()
self._update_flow_lines()
self._update_visible_lines()
self._update_vertex_lists()
self.top_group.top = self._get_top(self.lines)
# Reclamp view_y in case content height has changed and reset top of
# content.
self.view_y = self.view_y
self.top_group.top = self._get_top(self._get_lines())
if trigger_update_event:
self.dispatch_event('on_layout_update')
def _update_glyphs(self):
invalid_start, invalid_end = self.invalid_glyphs.validate()
if invalid_end - invalid_start <= 0:
return
# Find grapheme breaks and extend glyph range to encompass.
text = self.document.text
while invalid_start > 0:
if _grapheme_break(text[invalid_start - 1], text[invalid_start]):
break
invalid_start -= 1
len_text = len(text)
while invalid_end < len_text:
if _grapheme_break(text[invalid_end - 1], text[invalid_end]):
break
invalid_end += 1
# Update glyphs
runs = runlist.ZipRunIterator((
self._document.get_font_runs(dpi=self._dpi),
self._document.get_element_runs()))
for start, end, (font, element) in \
runs.ranges(invalid_start, invalid_end):
if element:
self.glyphs[start] = _InlineElementBox(element)
else:
text = self.document.text[start:end]
self.glyphs[start:end] = font.get_glyphs(text)
# Update owner runs
self._get_owner_runs(
self.owner_runs, self.glyphs, invalid_start, invalid_end)
# Updated glyphs need flowing
self.invalid_flow.invalidate(invalid_start, invalid_end)
def _update_flow_glyphs(self):
invalid_start, invalid_end = self.invalid_flow.validate()
if invalid_end - invalid_start <= 0:
return
# Find first invalid line
line_index = 0
for i, line in enumerate(self.lines):
if line.start >= invalid_start:
break
line_index = i
# Flow from previous line; fixes issue with adding a space into
# overlong line (glyphs before space would then flow back onto
# previous line). TODO Could optimise this by keeping track of where
# the overlong lines are.
line_index = max(0, line_index - 1)
# (No need to find last invalid line; the update loop below stops
# calling the flow generator when no more changes are necessary.)
try:
line = self.lines[line_index]
invalid_start = min(invalid_start, line.start)
line.delete(self)
line = self.lines[line_index] = _Line(invalid_start)
self.invalid_lines.invalidate(line_index, line_index + 1)
except IndexError:
line_index = 0
invalid_start = 0
line = _Line(0)
self.lines.append(line)
self.invalid_lines.insert(0, 1)
content_width_invalid = False
next_start = invalid_start
for line in self._flow_glyphs(self.glyphs, self.owner_runs,
invalid_start, len(self._document.text)):
try:
old_line = self.lines[line_index]
old_line.delete(self)
old_line_width = old_line.width + old_line.margin_left
new_line_width = line.width + line.margin_left
if (old_line_width == self.content_width and
new_line_width < old_line_width):
content_width_invalid = True
self.lines[line_index] = line
self.invalid_lines.invalidate(line_index, line_index + 1)
except IndexError:
self.lines.append(line)
self.invalid_lines.insert(line_index, 1)
next_start = line.start + line.length
line_index += 1
try:
next_line = self.lines[line_index]
if next_start == next_line.start and next_start > invalid_end:
# No more lines need to be modified, early exit.
break
except IndexError:
pass
else:
# The last line is at line_index - 1, if there are any more lines
# after that they are stale and need to be deleted.
if next_start == len(self._document.text) and line_index > 0:
for line in self.lines[line_index:]:
old_line_width = old_line.width + old_line.margin_left
if old_line_width == self.content_width:
content_width_invalid = True
line.delete(self)
del self.lines[line_index:]
if content_width_invalid:
# Rescan all lines to look for the new maximum content width
content_width = 0
for line in self.lines:
content_width = max(line.width + line.margin_left,
content_width)
self.content_width = content_width
def _update_flow_lines(self):
invalid_start, invalid_end = self.invalid_lines.validate()
if invalid_end - invalid_start <= 0:
return
invalid_end = self._flow_lines(self.lines, invalid_start, invalid_end)
# Invalidate lines that need new vertex lists.
self.invalid_vertex_lines.invalidate(invalid_start, invalid_end)
def _update_visible_lines(self):
start = sys.maxint
end = 0
for i, line in enumerate(self.lines):
if line.y + line.descent < self.view_y:
start = min(start, i)
if line.y + line.ascent > self.view_y - self.height:
end = max(end, i) + 1
# Delete newly invisible lines
for i in range(self.visible_lines.start, min(start, len(self.lines))):
self.lines[i].delete(self)
for i in range(end, min(self.visible_lines.end, len(self.lines))):
self.lines[i].delete(self)
# Invalidate newly visible lines
self.invalid_vertex_lines.invalidate(start, self.visible_lines.start)
self.invalid_vertex_lines.invalidate(self.visible_lines.end, end)
self.visible_lines.start = start
self.visible_lines.end = end
def _update_vertex_lists(self):
# Find lines that have been affected by style changes
style_invalid_start, style_invalid_end = self.invalid_style.validate()
self.invalid_vertex_lines.invalidate(
self.get_line_from_position(style_invalid_start),
self.get_line_from_position(style_invalid_end) + 1)
invalid_start, invalid_end = self.invalid_vertex_lines.validate()
if invalid_end - invalid_start <= 0:
return
colors_iter = self.document.get_style_runs('color')
background_iter = self.document.get_style_runs('background_color')
if self._selection_end - self._selection_start > 0:
colors_iter = runlist.OverriddenRunIterator(
colors_iter,
self._selection_start,
self._selection_end,
self._selection_color)
background_iter = runlist.OverriddenRunIterator(
background_iter,
self._selection_start,
self._selection_end,
self._selection_background_color)
context = _IncrementalLayoutContext(self, self._document,
colors_iter, background_iter)
for line in self.lines[invalid_start:invalid_end]:
line.delete(self)
context.line = line
y = line.y
# Early out if not visible
if y + line.descent > self.view_y:
continue
elif y + line.ascent < self.view_y - self.height:
break
self._create_vertex_lists(line.x, y, line.start,
line.boxes, context)
# Invalidate everything when width changes
def _set_width(self, width):
if width == self._width:
return
self.invalid_flow.invalidate(0, len(self.document.text))
super(IncrementalTextLayout, self)._set_width(width)
def _get_width(self):
return self._width
width = property(_get_width, _set_width)
# Recalculate visible lines when height changes
def _set_height(self, height):
if height == self._height:
return
super(IncrementalTextLayout, self)._set_height(height)
if self._update_enabled:
self._update_visible_lines()
self._update_vertex_lists()
def _get_height(self):
return self._height
height = property(_get_height, _set_height)
def _set_multiline(self, multiline):
self.invalid_flow.invalidate(0, len(self.document.text))
super(IncrementalTextLayout, self)._set_multiline(multiline)
def _get_multiline(self):
return self._multiline
multiline = property(_get_multiline, _set_multiline)
# Invalidate invisible/visible lines when y scrolls
def _set_view_y(self, view_y):
# view_y must be negative.
super(IncrementalTextLayout, self)._set_view_y(view_y)
self._update_visible_lines()
self._update_vertex_lists()
def _get_view_y(self):
return self.top_group.view_y
view_y = property(_get_view_y, _set_view_y)
# Visible selection
def set_selection(self, start, end):
'''Set the text selection range.
If ``start`` equals ``end`` no selection will be visible.
:Parameters:
`start` : int
Starting character position of selection.
`end` : int
End of selection, exclusive.
'''
start = max(0, start)
end = min(end, len(self.document.text))
if start == self._selection_start and end == self._selection_end:
return
if end > self._selection_start and start < self._selection_end:
# Overlapping, only invalidate difference
self.invalid_style.invalidate(min(start, self._selection_start),
max(start, self._selection_start))
self.invalid_style.invalidate(min(end, self._selection_end),
max(end, self._selection_end))
else:
# Non-overlapping, invalidate both ranges
self.invalid_style.invalidate(self._selection_start,
self._selection_end)
self.invalid_style.invalidate(start, end)
self._selection_start = start
self._selection_end = end
self._update()
selection_start = property(
lambda self: self._selection_start,
lambda self, v: self.set_selection(v, self._selection_end),
doc='''Starting position of the active selection.
:see: `set_selection`
:type: int
''')
selection_end = property(
lambda self: self._selection_end,
lambda self, v: self.set_selection(self._selection_start, v),
doc='''End position of the active selection (exclusive).
:see: `set_selection`
:type: int
''')
def _get_selection_color(self):
return self._selection_color
def _set_selection_color(self, color):
self._selection_color = color
self.invalid_style.invalidate(self._selection_start,
self._selection_end)
selection_color = property(_get_selection_color, _set_selection_color,
doc='''Text color of active selection.
The color is an RGBA tuple with components in range [0, 255].
:type: (int, int, int, int)
''')
def _get_selection_background_color(self):
return self._selection_background_color
def _set_selection_background_color(self, background_color):
self._selection_background_color = background_color
self.invalid_style.invalidate(self._selection_start,
self._selection_end)
selection_background_color = property(_get_selection_background_color,
_set_selection_background_color,
doc='''Background color of active
selection.
The color is an RGBA tuple with components in range [0, 255].
:type: (int, int, int, int)
''')
# Coordinate translation
def get_position_from_point(self, x, y):
'''Get the closest document position to a point.
:Parameters:
`x` : int
X coordinate
`y` : int
Y coordinate
'''
line = self.get_line_from_point(x, y)
return self.get_position_on_line(line, x)
def get_point_from_position(self, position, line=None):
'''Get the X, Y coordinates of a position in the document.
The position that ends a line has an ambiguous point: it can be either
the end of the line, or the beginning of the next line. You may
optionally specify a line index to disambiguate the case.
The resulting Y coordinate gives the baseline of the line.
:Parameters:
`position` : int
Character position within document.
`line` : int
Line index.
:rtype: (int, int)
:return: (x, y)
'''
if line is None:
line = self.lines[0]
for next_line in self.lines:
if next_line.start > position:
break
line = next_line
else:
line = self.lines[line]
x = line.x
baseline = self._document.get_style('baseline', max(0, position - 1))
if baseline is None:
baseline = 0
else:
baseline = self._parse_distance(baseline)
position -= line.start
for box in line.boxes:
if position - box.length <= 0:
x += box.get_point_in_box(position)
break
position -= box.length
x += box.advance
return (x + self.top_group.translate_x,
line.y + self.top_group.translate_y + baseline)
def get_line_from_point(self, x, y):
'''Get the closest line index to a point.
:Parameters:
`x` : int
X coordinate.
`y` : int
Y coordinate.
:rtype: int
'''
x -= self.top_group.translate_x
y -= self.top_group.translate_y
line_index = 0
for line in self.lines:
if y > line.y + line.descent:
break
line_index += 1
if line_index >= len(self.lines):
line_index = len(self.lines) - 1
return line_index
def get_point_from_line(self, line):
'''Get the X, Y coordinates of a line index.
:Parameters:
`line` : int
Line index.
:rtype: (int, int)
:return: (x, y)
'''
line = self.lines[line]
return (line.x + self.top_group.translate_x,
line.y + self.top_group.translate_y)
def get_line_from_position(self, position):
'''Get the line index of a character position in the document.
:Parameters:
`position` : int
Document position.
:rtype: int
'''
line = -1
for next_line in self.lines:
if next_line.start > position:
break
line += 1
return line
def get_position_from_line(self, line):
'''Get the first document character position of a given line index.
:Parameters:
`line` : int
Line index.
:rtype: int
'''
return self.lines[line].start
def get_position_on_line(self, line, x):
'''Get the closest document position for a given line index and X
coordinate.
:Parameters:
`line` : int
Line index.
`x` : int
X coordinate.
:rtype: int
'''
line = self.lines[line]
x -= self.top_group.translate_x
position = line.start
last_glyph_x = line.x
for box in line.boxes:
if 0 <= x - last_glyph_x < box.advance:
position += box.get_position_in_box(x - last_glyph_x)
break
last_glyph_x += box.advance
position += box.length
return position
def get_line_count(self):
'''Get the number of lines in the text layout.
:rtype: int
'''
return len(self.lines)
def ensure_line_visible(self, line):
'''Adjust `view_y` so that the line with the given index is visible.
:Parameters:
`line` : int
Line index.
'''
line = self.lines[line]
y1 = line.y + line.ascent
y2 = line.y + line.descent
if y1 > self.view_y:
self.view_y = y1
elif y2 < self.view_y - self.height:
self.view_y = y2 + self.height
def ensure_x_visible(self, x):
'''Adjust `view_x` so that the given X coordinate is visible.
The X coordinate is given relative to the current `view_x`.
:Parameters:
`x` : int
X coordinate
'''
if x <= self.view_x + 10:
self.view_x = x - 10
elif x >= self.view_x + self.width:
self.view_x = x - self.width + 10
elif (x >= self.view_x + self.width - 10 and
self.content_width > self.width):
self.view_x = x - self.width + 10
if _is_epydoc:
def on_layout_update(self):
'''Some or all of the layout text was reflowed.
Text reflow is caused by document edits or changes to the layout's
size. Changes to the layout's position or active selection, and
certain document edits such as text color, do not cause a reflow.
Handle this event to update the position of a graphical element
that depends on the laid out position of a glyph or line.
:event:
'''
IncrementalTextLayout.register_event_type('on_layout_update')
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id: $
'''Text formatting, layout and display.
This module provides classes for loading styled documents from text files,
HTML files and a pyglet-specific markup format. Documents can be styled with
multiple fonts, colours, styles, text sizes, margins, paragraph alignments,
and so on.
Using the layout classes, documents can be laid out on a single line or
word-wrapped to fit a rectangle. A layout can then be efficiently drawn in
a window or updated incrementally (for example, to support interactive text
editing).
The label classes provide a simple interface for the common case where an
application simply needs to display some text in a window.
A plain text label can be created with::
label = pyglet.text.Label('Hello, world',
font_name='Times New Roman',
font_size=36,
x=10, y=10)
Alternatively, a styled text label using HTML can be created with::
label = pyglet.text.HTMLLabel('<b>Hello</b>, <i>world</i>',
x=10, y=10)
Either label can then be drawn at any time with::
label.draw()
For details on the subset of HTML supported, see `pyglet.text.formats.html`.
Refer to the Programming Guide for advanced usage of the document and layout
classes, including interactive editing, embedding objects within documents and
creating scrollable layouts.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import os.path
import pyglet
from pyglet.text import layout, document, caret
class DocumentDecodeException(Exception):
'''An error occurred decoding document text.'''
pass
class DocumentDecoder(object):
'''Abstract document decoder.
'''
def decode(self, text, location=None):
'''Decode document text.
:Parameters:
`text` : str
Text to decode
`location` : `Location`
Location to use as base path for additional resources
referenced within the document (for example, HTML images).
:rtype: `AbstractDocument`
'''
raise NotImplementedError('abstract')
def get_decoder(filename, mimetype=None):
'''Get a document decoder for the given filename and MIME type.
If `mimetype` is omitted it is guessed from the filename extension.
The following MIME types are supported:
``text/plain``
Plain text
``text/html``
HTML 4 Transitional
``text/vnd.pyglet-attributed``
Attributed text; see `pyglet.text.formats.attributed`
`DocumentDecodeException` is raised if another MIME type is given.
:Parameters:
`filename` : str
Filename to guess the MIME type from. If a MIME type is given,
the filename is ignored.
`mimetype` : str
MIME type to lookup, or ``None`` to guess the type from the
filename.
:rtype: `DocumentDecoder`
'''
if mimetype is None:
_, ext = os.path.splitext(filename)
if ext.lower() in ('.htm', '.html', '.xhtml'):
mimetype = 'text/html'
else:
mimetype = 'text/plain'
if mimetype == 'text/plain':
from pyglet.text.formats import plaintext
return plaintext.PlainTextDecoder()
elif mimetype == 'text/html':
from pyglet.text.formats import html
return html.HTMLDecoder()
elif mimetype == 'text/vnd.pyglet-attributed':
from pyglet.text.formats import attributed
return attributed.AttributedTextDecoder()
else:
raise DocumentDecodeException('Unknown format "%s"' % mimetype)
def load(filename, file=None, mimetype=None):
'''Load a document from a file.
:Parameters:
`filename` : str
Filename of document to load.
`file` : file-like object
File object containing encoded data. If omitted, `filename` is
loaded from disk.
`mimetype` : str
MIME type of the document. If omitted, the filename extension is
used to guess a MIME type. See `get_decoder` for a list of
supported MIME types.
:rtype: `AbstractDocument`
'''
decoder = get_decoder(filename, mimetype)
if file is None:
file = open(filename)
location = pyglet.resource.FileLocation(os.path.dirname(filename))
return decoder.decode(file.read(), location)
def decode_html(text, location=None):
'''Create a document directly from some HTML formatted text.
:Parameters:
`text` : str
HTML data to decode.
`location` : str
Location giving the base path for additional resources
referenced from the document (e.g., images).
:rtype: `FormattedDocument`
'''
decoder = get_decoder(None, 'text/html')
return decoder.decode(text, location)
def decode_attributed(text):
'''Create a document directly from some attributed text.
See `pyglet.text.formats.attributed` for a description of attributed text.
:Parameters:
`text` : str
Attributed text to decode.
:rtype: `FormattedDocument`
'''
decoder = get_decoder(None, 'text/vnd.pyglet-attributed')
return decoder.decode(text)
def decode_text(text):
'''Create a document directly from some plain text.
:Parameters:
`text` : str
Plain text to initialise the document with.
:rtype: `UnformattedDocument`
'''
decoder = get_decoder(None, 'text/plain')
return decoder.decode(text)
class DocumentLabel(layout.TextLayout):
'''Base label class.
A label is a layout that exposes convenience methods for manipulating the
associated document.
'''
def __init__(self, document=None,
x=0, y=0, width=None, height=None,
anchor_x='left', anchor_y='baseline',
multiline=False, dpi=None, batch=None, group=None):
'''Create a label for a given document.
:Parameters:
`document` : `AbstractDocument`
Document to attach to the layout.
`x` : int
X coordinate of the label.
`y` : int
Y coordinate of the label.
`width` : int
Width of the label in pixels, or None
`height` : int
Height of the label in pixels, or None
`anchor_x` : str
Anchor point of the X coordinate: one of ``"left"``,
``"center"`` or ``"right"``.
`anchor_y` : str
Anchor point of the Y coordinate: one of ``"bottom"``,
``"baseline"``, ``"center"`` or ``"top"``.
`multiline` : bool
If True, the label will be word-wrapped and accept newline
characters. You must also set the width of the label.
`dpi` : float
Resolution of the fonts in this layout. Defaults to 96.
`batch` : `Batch`
Optional graphics batch to add the label to.
`group` : `Group`
Optional graphics group to use.
'''
super(DocumentLabel, self).__init__(document,
width=width, height=height,
multiline=multiline,
dpi=dpi, batch=batch, group=group)
self._x = x
self._y = y
self._anchor_x = anchor_x
self._anchor_y = anchor_y
self._update()
def _get_text(self):
return self.document.text
def _set_text(self, text):
self.document.text = text
text = property(_get_text, _set_text,
doc='''The text of the label.
:type: str
''')
def _get_color(self):
return self.document.get_style('color')
def _set_color(self, color):
self.document.set_style(0, len(self.document.text),
{'color': color})
color = property(_get_color, _set_color,
doc='''Text color.
Color is a 4-tuple of RGBA components, each in range [0, 255].
:type: (int, int, int, int)
''')
def _get_font_name(self):
return self.document.get_style('font_name')
def _set_font_name(self, font_name):
self.document.set_style(0, len(self.document.text),
{'font_name': font_name})
font_name = property(_get_font_name, _set_font_name,
doc='''Font family name.
The font name, as passed to `pyglet.font.load`. A list of names can
optionally be given: the first matching font will be used.
:type: str or list
''')
def _get_font_size(self):
return self.document.get_style('font_size')
def _set_font_size(self, font_size):
self.document.set_style(0, len(self.document.text),
{'font_size': font_size})
font_size = property(_get_font_size, _set_font_size,
doc='''Font size, in points.
:type: float
''')
def _get_bold(self):
return self.document.get_style('bold')
def _set_bold(self, bold):
self.document.set_style(0, len(self.document.text),
{'bold': bold})
bold = property(_get_bold, _set_bold,
doc='''Bold font style.
:type: bool
''')
def _get_italic(self):
return self.document.get_style('italic')
def _set_italic(self, italic):
self.document.set_style(0, len(self.document.text),
{'italic': italic})
italic = property(_get_italic, _set_italic,
doc='''Italic font style.
:type: bool
''')
def get_style(self, name):
'''Get a document style value by name.
If the document has more than one value of the named style,
`pyglet.text.document.STYLE_INDETERMINATE` is returned.
:Parameters:
`name` : str
Style name to query. See documentation for
`pyglet.text.layout` for known style names.
:rtype: object
'''
return self.document.get_style_range(name, 0, len(self.document.text))
def set_style(self, name, value):
'''Set a document style value by name over the whole document.
:Parameters:
`name` : str
Name of the style to set. See documentation for
`pyglet.text.layout` for known style names.
`value` : object
Value of the style.
'''
self.document.set_style(0, len(self.document.text), {name: value})
class Label(DocumentLabel):
'''Plain text label.
'''
def __init__(self, text='',
font_name=None, font_size=None, bold=False, italic=False,
color=(255, 255, 255, 255),
x=0, y=0, width=None, height=None,
anchor_x='left', anchor_y='baseline',
align='left',
multiline=False, dpi=None, batch=None, group=None):
'''Create a plain text label.
:Parameters:
`text` : str
Text to display.
`font_name` : str or list
Font family name(s). If more than one name is given, the
first matching name is used.
`font_size` : float
Font size, in points.
`bold` : bool
Bold font style.
`italic` : bool
Italic font style.
`color` : (int, int, int, int)
Font colour, as RGBA components in range [0, 255].
`x` : int
X coordinate of the label.
`y` : int
Y coordinate of the label.
`width` : int
Width of the label in pixels, or None
`height` : int
Height of the label in pixels, or None
`anchor_x` : str
Anchor point of the X coordinate: one of ``"left"``,
``"center"`` or ``"right"``.
`anchor_y` : str
Anchor point of the Y coordinate: one of ``"bottom"``,
``"baseline"``, ``"center"`` or ``"top"``.
`align` : str
Horizontal alignment of text on a line, only applies if
a width is supplied. One of ``"left"``, ``"center"``
or ``"right"``.
`multiline` : bool
If True, the label will be word-wrapped and accept newline
characters. You must also set the width of the label.
`dpi` : float
Resolution of the fonts in this layout. Defaults to 96.
`batch` : `Batch`
Optional graphics batch to add the label to.
`group` : `Group`
Optional graphics group to use.
'''
document = decode_text(text)
super(Label, self).__init__(document, x, y, width, height,
anchor_x, anchor_y,
multiline, dpi, batch, group)
self.document.set_style(0, len(self.document.text), {
'font_name': font_name,
'font_size': font_size,
'bold': bold,
'italic': italic,
'color': color,
'align': align,
})
class HTMLLabel(DocumentLabel):
'''HTML formatted text label.
A subset of HTML 4.01 is supported. See `pyglet.text.formats.html` for
details.
'''
def __init__(self, text='', location=None,
x=0, y=0, width=None, height=None,
anchor_x='left', anchor_y='baseline',
multiline=False, dpi=None, batch=None, group=None):
'''Create a label with an HTML string.
:Parameters:
`text` : str
HTML formatted text to display.
`location` : `Location`
Location object for loading images referred to in the
document. By default, the working directory is used.
`x` : int
X coordinate of the label.
`y` : int
Y coordinate of the label.
`width` : int
Width of the label in pixels, or None
`height` : int
Height of the label in pixels, or None
`anchor_x` : str
Anchor point of the X coordinate: one of ``"left"``,
``"center"`` or ``"right"``.
`anchor_y` : str
Anchor point of the Y coordinate: one of ``"bottom"``,
``"baseline"``, ``"center"`` or ``"top"``.
`multiline` : bool
If True, the label will be word-wrapped and render paragraph
and line breaks. You must also set the width of the label.
`dpi` : float
Resolution of the fonts in this layout. Defaults to 96.
`batch` : `Batch`
Optional graphics batch to add the label to.
`group` : `Group`
Optional graphics group to use.
'''
self._text = text
self._location = location
document = decode_html(text, location)
super(HTMLLabel, self).__init__(document, x, y, width, height,
anchor_x, anchor_y,
multiline, dpi, batch, group)
def _set_text(self, text):
self._text = text
self.document = decode_html(text, self._location)
def _get_text(self):
return self._text
text = property(_get_text, _set_text,
doc='''HTML formatted text of the label.
:type: str
''')
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Extensible attributed text format for representing pyglet formatted
documents.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import operator
import parser
import re
import token
import pyglet
_pattern = re.compile(r'''
(?P<escape_hex>\{\#x(?P<escape_hex_val>[0-9a-fA-F]+)\})
| (?P<escape_dec>\{\#(?P<escape_dec_val>[0-9]+)\})
| (?P<escape_lbrace>\{\{)
| (?P<escape_rbrace>\}\})
| (?P<attr>\{
(?P<attr_name>[^ \{\}]+)\s+
(?P<attr_val>[^\}]+)\})
| (?P<nl_hard1>\n(?=[ \t]))
| (?P<nl_hard2>\{\}\n)
| (?P<nl_soft>\n(?=\S))
| (?P<nl_para>\n\n+)
| (?P<text>[^\{\}\n]+)
''', re.VERBOSE | re.DOTALL)
class AttributedTextDecoder(pyglet.text.DocumentDecoder):
def decode(self, text, location=None):
self.doc = pyglet.text.document.FormattedDocument()
self.length = 0
self.attributes = {}
next_trailing_space = True
trailing_newline = True
for m in _pattern.finditer(text):
group = m.lastgroup
trailing_space = True
if group == 'text':
t = m.group('text')
self.append(t)
trailing_space = t.endswith(' ')
trailing_newline = False
elif group == 'nl_soft':
if not next_trailing_space:
self.append(' ')
trailing_newline = False
elif group in ('nl_hard1', 'nl_hard2'):
self.append('\n')
trailing_newline = True
elif group == 'nl_para':
self.append(m.group('nl_para')[1:]) # ignore the first \n
trailing_newline = True
elif group == 'attr':
try:
ast = parser.expr(m.group('attr_val'))
if self.safe(ast):
val = eval(ast.compile())
else:
val = None
except (parser.ParserError, SyntaxError):
val = None
name = m.group('attr_name')
if name[0] == '.':
if trailing_newline:
self.attributes[name[1:]] = val
else:
self.doc.set_paragraph_style(self.length, self.length,
{name[1:]: val})
else:
self.attributes[name] = val
elif group == 'escape_dec':
self.append(unichr(int(m.group('escape_dec_val'))))
elif group == 'escape_hex':
self.append(unichr(int(m.group('escape_hex_val'), 16)))
elif group == 'escape_lbrace':
self.append('{')
elif group == 'escape_rbrace':
self.append('}')
next_trailing_space = trailing_space
return self.doc
def append(self, text):
self.doc.insert_text(self.length, text, self.attributes)
self.length += len(text)
self.attributes.clear()
_safe_names = ('True', 'False', 'None')
def safe(self, ast):
tree = ast.totuple()
return self.safe_node(tree)
def safe_node(self, node):
if token.ISNONTERMINAL(node[0]):
return reduce(operator.and_, map(self.safe_node, node[1:]))
elif node[0] == token.NAME:
return node[1] in self._safe_names
else:
return True
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Decode HTML into attributed text.
A subset of HTML 4.01 Transitional is implemented. The following elements are
supported fully::
B BLOCKQUOTE BR CENTER CODE DD DIR DL EM FONT H1 H2 H3 H4 H5 H6 I IMG KBD
LI MENU OL P PRE Q SAMP STRONG SUB SUP TT U UL VAR
The mark (bullet or number) of a list item is separated from the body of the
list item with a tab, as the pyglet document model does not allow
out-of-stream text. This means lists display as expected, but behave a little
oddly if edited.
No CSS styling is supported.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import HTMLParser
import htmlentitydefs
import re
import pyglet
from pyglet.text.formats import structured
def _hex_color(val):
return [(val >> 16) & 0xff, (val >> 8) & 0xff, val & 0xff, 255]
_color_names = {
'black': _hex_color(0x000000),
'silver': _hex_color(0xc0c0c0),
'gray': _hex_color(0x808080),
'white': _hex_color(0xffffff),
'maroon': _hex_color(0x800000),
'red': _hex_color(0xff0000),
'purple': _hex_color(0x800080),
'fucsia': _hex_color(0x008000),
'green': _hex_color(0x00ff00),
'lime': _hex_color(0xffff00),
'olive': _hex_color(0x808000),
'yellow': _hex_color(0xff0000),
'navy': _hex_color(0x000080),
'blue': _hex_color(0x0000ff),
'teal': _hex_color(0x008080),
'aqua': _hex_color(0x00ffff),
}
def _parse_color(value):
if value.startswith('#'):
return _hex_color(int(value[1:], 16))
else:
try:
return _color_names[value.lower()]
except KeyError:
raise ValueError()
_whitespace_re = re.compile(u'[\u0020\u0009\u000c\u200b\r\n]+', re.DOTALL)
_metadata_elements = ['head', 'title']
_block_elements = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
'ul', 'ol', 'dir', 'menu',
'pre', 'dl', 'div', 'center',
'noscript', 'noframes', 'blockquote', 'form',
'isindex', 'hr', 'table', 'fieldset', 'address',
# Incorrect, but we treat list items as blocks:
'li', 'dd', 'dt', ]
_block_containers = ['_top_block',
'body', 'div', 'center', 'object', 'applet',
'blockquote', 'ins', 'del', 'dd', 'li', 'form',
'fieldset', 'button', 'th', 'td', 'iframe', 'noscript',
'noframes',
# Incorrect, but we treat list items as blocks:
'ul', 'ol', 'dir', 'menu', 'dl']
class HTMLDecoder(HTMLParser.HTMLParser, structured.StructuredTextDecoder):
'''Decoder for HTML documents.
'''
#: Default style attributes for unstyled text in the HTML document.
#:
#: :type: dict
default_style = {
'font_name': 'Times New Roman',
'font_size': 12,
'margin_bottom': '12pt',
}
#: Map HTML font sizes to actual font sizes, in points.
#:
#: :type: dict
font_sizes = {
1: 8,
2: 10,
3: 12,
4: 14,
5: 18,
6: 24,
7: 48
}
def decode_structured(self, text, location):
self.location = location
self._font_size_stack = [3]
self.list_stack.append(structured.UnorderedListBuilder({}))
self.strip_leading_space = True
self.block_begin = True
self.need_block_begin = False
self.element_stack = ['_top_block']
self.in_metadata = False
self.in_pre = False
self.push_style('_default', self.default_style)
self.feed(text)
self.close()
def get_image(self, filename):
return pyglet.image.load(filename, file=self.location.open(filename))
def prepare_for_data(self):
if self.need_block_begin:
self.add_text('\n')
self.block_begin = True
self.need_block_begin = False
def handle_data(self, data):
if self.in_metadata:
return
if self.in_pre:
self.add_text(data)
else:
data = _whitespace_re.sub(' ', data)
if data.strip():
self.prepare_for_data()
if self.block_begin or self.strip_leading_space:
data = data.lstrip()
self.block_begin = False
self.add_text(data)
self.strip_leading_space = data.endswith(' ')
def handle_starttag(self, tag, case_attrs):
if self.in_metadata:
return
element = tag.lower()
attrs = {}
for key, value in case_attrs:
attrs[key.lower()] = value
if element in _metadata_elements:
self.in_metadata = True
elif element in _block_elements:
# Pop off elements until we get to a block container.
while self.element_stack[-1] not in _block_containers:
self.handle_endtag(self.element_stack[-1])
if not self.block_begin:
self.add_text('\n')
self.block_begin = True
self.need_block_begin = False
self.element_stack.append(element)
style = {}
if element in ('b', 'strong'):
style['bold'] = True
elif element in ('i', 'em', 'var'):
style['italic'] = True
elif element in ('tt', 'code', 'samp', 'kbd'):
style['font_name'] = 'Courier New'
elif element == 'u':
color = self.current_style.get('color')
if color is None:
color = [0, 0, 0, 255]
style['underline'] = color
elif element == 'font':
if 'face' in attrs:
style['font_name'] = attrs['face'].split(',')
if 'size' in attrs:
size = attrs['size']
try:
if size.startswith('+'):
size = self._font_size_stack[-1] + int(size[1:])
elif size.startswith('-'):
size = self._font_size_stack[-1] - int(size[1:])
else:
size = int(size)
except ValueError:
size = 3
self._font_size_stack.append(size)
if size in self.font_sizes:
style['font_size'] = self.font_sizes.get(size, 3)
else:
self._font_size_stack.append(self._font_size_stack[-1])
if 'color' in attrs:
try:
style['color'] = _parse_color(attrs['color'])
except ValueError:
pass
elif element == 'sup':
size = self._font_size_stack[-1] - 1
style['font_size'] = self.font_sizes.get(size, 1)
style['baseline'] = '3pt'
elif element == 'sub':
size = self._font_size_stack[-1] - 1
style['font_size'] = self.font_sizes.get(size, 1)
style['baseline'] = '-3pt'
elif element == 'h1':
style['font_size'] = 24
style['bold'] = True
style['align'] = 'center'
elif element == 'h2':
style['font_size'] = 18
style['bold'] = True
elif element == 'h3':
style['font_size'] = 16
style['bold'] = True
elif element == 'h4':
style['font_size'] = 14
style['bold'] = True
elif element == 'h5':
style['font_size'] = 12
style['bold'] = True
elif element == 'h6':
style['font_size'] = 12
style['italic'] = True
elif element == 'br':
self.add_text(u'\u2028')
self.strip_leading_space = True
elif element == 'p':
if attrs.get('align') in ('left', 'center', 'right'):
style['align'] = attrs['align']
elif element == 'center':
style['align'] = 'center'
elif element == 'pre':
style['font_name'] = 'Courier New'
style['margin_bottom'] = 0
self.in_pre = True
elif element == 'blockquote':
left_margin = self.current_style.get('margin_left') or 0
right_margin = self.current_style.get('margin_right') or 0
style['margin_left'] = left_margin + 60
style['margin_right'] = right_margin + 60
elif element == 'q':
self.handle_data(u'\u201c')
elif element == 'ol':
try:
start = int(attrs.get('start', 1))
except ValueError:
start = 1
format = attrs.get('type', '1') + '.'
builder = structured.OrderedListBuilder(start, format)
builder.begin(self, style)
self.list_stack.append(builder)
elif element in ('ul', 'dir', 'menu'):
type = attrs.get('type', 'disc').lower()
if type == 'circle':
mark = u'\u25cb'
elif type == 'square':
mark = u'\u25a1'
else:
mark = u'\u25cf'
builder = structured.UnorderedListBuilder(mark)
builder.begin(self, style)
self.list_stack.append(builder)
elif element == 'li':
self.list_stack[-1].item(self, style)
self.strip_leading_space = True
elif element == 'dl':
style['margin_bottom'] = 0
elif element == 'dd':
left_margin = self.current_style.get('margin_left') or 0
style['margin_left'] = left_margin + 30
elif element == 'img':
image = self.get_image(attrs.get('src'))
if image:
width = attrs.get('width')
if width:
width = int(width)
height = attrs.get('height')
if height:
height = int(height)
self.prepare_for_data()
self.add_element(structured.ImageElement(image, width, height))
self.strip_leading_space = False
self.push_style(element, style)
def handle_endtag(self, tag):
element = tag.lower()
if element not in self.element_stack:
return
self.pop_style(element)
while self.element_stack.pop() != element:
pass
if element in _metadata_elements:
self.in_metadata = False
elif element in _block_elements:
self.block_begin = False
self.need_block_begin = True
if element == 'font' and len(self._font_size_stack) > 1:
self._font_size_stack.pop()
elif element == 'pre':
self.in_pre = False
elif element == 'q':
self.handle_data(u'\u201d')
elif element in ('ul', 'ol'):
if len(self.list_stack) > 1:
self.list_stack.pop()
def handle_entityref(self, name):
if name in htmlentitydefs.name2codepoint:
self.handle_data(unichr(htmlentitydefs.name2codepoint[name]))
def handle_charref(self, name):
name = name.lower()
try:
if name.startswith('x'):
self.handle_data(unichr(int(name[1:], 16)))
else:
self.handle_data(unichr(int(name)))
except ValueError:
pass
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Document formats.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Plain text decoder.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import pyglet
class PlainTextDecoder(pyglet.text.DocumentDecoder):
def decode(self, text, location=None):
document = pyglet.text.document.UnformattedDocument()
document.insert_text(0, text)
return document
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Base class for structured (hierarchical) document formats.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import re
import pyglet
class ImageElement(pyglet.text.document.InlineElement):
def __init__(self, image, width=None, height=None):
self.image = image.get_texture()
self.width = width is None and image.width or width
self.height = height is None and image.height or height
self.vertex_lists = {}
anchor_y = self.height // image.height * image.anchor_y
ascent = max(0, self.height - anchor_y)
descent = min(0, -anchor_y)
super(ImageElement, self).__init__(ascent, descent, self.width)
def place(self, layout, x, y):
group = pyglet.graphics.TextureGroup(self.image.texture,
layout.top_group)
x1 = x
y1 = y + self.descent
x2 = x + self.width
y2 = y + self.height + self.descent
vertex_list = layout.batch.add(4, pyglet.gl.GL_QUADS, group,
('v2i', (x1, y1, x2, y1, x2, y2, x1, y2)),
('c3B', (255, 255, 255) * 4),
('t3f', self.image.tex_coords))
self.vertex_lists[layout] = vertex_list
def remove(self, layout):
self.vertex_lists[layout].delete()
del self.vertex_lists[layout]
def _int_to_roman(input):
# From http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81611
if not 0 < input < 4000:
raise ValueError, "Argument must be between 1 and 3999"
ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)
nums = ('M', 'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I')
result = ""
for i in range(len(ints)):
count = int(input / ints[i])
result += nums[i] * count
input -= ints[i] * count
return result
class ListBuilder(object):
def begin(self, decoder, style):
'''Begin a list.
:Parameters:
`decoder` : `StructuredTextDecoder`
Decoder.
`style` : dict
Style dictionary that applies over the entire list.
'''
left_margin = decoder.current_style.get('margin_left') or 0
tab_stops = decoder.current_style.get('tab_stops')
if tab_stops:
tab_stops = list(tab_stops)
else:
tab_stops = []
tab_stops.append(left_margin + 50)
style['margin_left'] = left_margin + 50
style['indent'] = -30
style['tab_stops'] = tab_stops
def item(self, decoder, style, value=None):
'''Begin a list item.
:Parameters:
`decoder` : `StructuredTextDecoder`
Decoder.
`style` : dict
Style dictionary that applies over the list item.
`value` : str
Optional value of the list item. The meaning is list-type
dependent.
'''
mark = self.get_mark(value)
if mark:
decoder.add_text(mark)
decoder.add_text('\t')
def get_mark(self, value=None):
'''Get the mark text for the next list item.
:Parameters:
`value` : str
Optional value of the list item. The meaning is list-type
dependent.
:rtype: str
'''
return ''
class UnorderedListBuilder(ListBuilder):
def __init__(self, mark):
'''Create an unordered list with constant mark text.
:Parameters:
`mark` : str
Mark to prepend to each list item.
'''
self.mark = mark
def get_mark(self, value):
return self.mark
class OrderedListBuilder(ListBuilder):
format_re = re.compile('(.*?)([1aAiI])(.*)')
def __init__(self, start, format):
'''Create an ordered list with sequentially numbered mark text.
The format is composed of an optional prefix text, a numbering
scheme character followed by suffix text. Valid numbering schemes
are:
``1``
Decimal Arabic
``a``
Lowercase alphanumeric
``A``
Uppercase alphanumeric
``i``
Lowercase Roman
``I``
Uppercase Roman
Prefix text may typically be ``(`` or ``[`` and suffix text is
typically ``.``, ``)`` or empty, but either can be any string.
:Parameters:
`start` : int
First list item number.
`format` : str
Format style, for example ``"1."``.
'''
self.next_value = start
self.prefix, self.numbering, self.suffix = self.format_re.match(format).groups()
assert self.numbering in '1aAiI'
def get_mark(self, value):
if value is None:
value = self.next_value
self.next_value = value + 1
if self.numbering in 'aA':
try:
mark = 'abcdefghijklmnopqrstuvwxyz'[value - 1]
except ValueError:
mark = '?'
if self.numbering == 'A':
mark = mark.upper()
return '%s%s%s' % (self.prefix, mark, self.suffix)
elif self.numbering in 'iI':
try:
mark = _int_to_roman(value)
except ValueError:
mark = '?'
if self.numbering == 'i':
mark = mark.lower()
return '%s%s%s' % (self.prefix, mark, self.suffix)
else:
return '%s%d%s' % (self.prefix, value, self.suffix)
class StructuredTextDecoder(pyglet.text.DocumentDecoder):
def decode(self, text, location=None):
self.len_text = 0
self.current_style = {}
self.next_style = {}
self.stack = []
self.list_stack = []
self.document = pyglet.text.document.FormattedDocument()
if location is None:
location = pyglet.resource.FileLocation('')
self.decode_structured(text, location)
return self.document
def decode_structured(self, text, location):
raise NotImplementedError('abstract')
def push_style(self, key, styles):
old_styles = {}
for name in styles.keys():
old_styles[name] = self.current_style.get(name)
self.stack.append((key, old_styles))
self.current_style.update(styles)
self.next_style.update(styles)
def pop_style(self, key):
# Don't do anything if key is not in stack
for match, _ in self.stack:
if key == match:
break
else:
return
# Remove all innermost elements until key is closed.
while True:
match, old_styles = self.stack.pop()
self.next_style.update(old_styles)
self.current_style.update(old_styles)
if match == key:
break
def add_text(self, text):
self.document.insert_text(self.len_text, text, self.next_style)
self.next_style.clear()
self.len_text += len(text)
def add_element(self, element):
self.document.insert_element(self.len_text, element, self.next_style)
self.next_style.clear()
self.len_text += 1
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id:$
'''Formatted and unformatted document interfaces used by text layout.
Abstract representation
=======================
Styled text in pyglet is represented by one of the `AbstractDocument` classes,
which manage the state representation of text and style independently of how
it is loaded or rendered.
A document consists of the document text (a Unicode string) and a set of
named style ranges. For example, consider the following (artificial)
example::
0 5 10 15 20
The cat sat on the mat.
+++++++ +++++++ "bold"
++++++ "italic"
If this example were to be rendered, "The cat" and "the mat" would be in bold,
and "on the" in italics. Note that the second "the" is both bold and italic.
The document styles recorded for this example would be ``"bold"`` over ranges
(0-7, 15-22) and ``"italic"`` over range (12-18). Overlapping styles are
permitted; unlike HTML and other structured markup, the ranges need not be
nested.
The document has no knowledge of the semantics of ``"bold"`` or ``"italic"``,
it stores only the style names. The pyglet layout classes give meaning to
these style names in the way they are rendered; but you are also free to
invent your own style names (which will be ignored by the layout classes).
This can be useful to tag areas of interest in a document, or maintain
references back to the source material.
As well as text, the document can contain arbitrary elements represented by
`InlineElement`. An inline element behaves like a single character in the
documented, but can be rendered by the application.
Paragraph breaks
================
Paragraph breaks are marked with a "newline" character (U+0010). The Unicode
paragraph break (U+2029) can also be used.
Line breaks (U+2028) can be used to force a line break within a paragraph.
See Unicode recommendation UTR #13 for more information:
http://unicode.org/reports/tr13/tr13-5.html.
Document classes
================
Any class implementing `AbstractDocument` provides an interface to a
document model as described above. In theory a structured document such as
HTML or XML could export this model, though the classes provided by pyglet
implement only unstructured documents.
The `UnformattedDocument` class assumes any styles set are set over the entire
document. So, regardless of the range specified when setting a ``"bold"``
style attribute, for example, the entire document will receive that style.
The `FormattedDocument` class implements the document model directly, using
the `RunList` class to represent style runs efficiently.
Style attributes
================
The following character style attribute names are recognised by pyglet:
``font_name``
Font family name, as given to `pyglet.font.load`.
``font_size``
Font size, in points.
``bold``
Boolean.
``italic``
Boolean.
``underline``
4-tuple of ints in range (0, 255) giving RGBA underline color, or None
(default) for no underline.
``kerning``
Additional space to insert between glyphs, in points. Defaults to 0.
``baseline``
Offset of glyph baseline from line baseline, in points. Positive values
give a superscript, negative values give a subscript. Defaults to 0.
``color``
4-tuple of ints in range (0, 255) giving RGBA text color
``background_color``
4-tuple of ints in range (0, 255) giving RGBA text background color; or
``None`` for no background fill.
The following paragraph style attribute names are recognised by pyglet. Note
that paragraph styles are handled no differently from character styles by the
document: it is the application's responsibility to set the style over an
entire paragraph, otherwise results are undefined.
``align``
``left`` (default), ``center`` or ``right``.
``indent``
Additional horizontal space to insert before the first
``leading``
Additional space to insert between consecutive lines within a paragraph,
in points. Defaults to 0.
``line_spacing``
Distance between consecutive baselines in a paragraph, in points.
Defaults to ``None``, which automatically calculates the tightest line
spacing for each line based on the font ascent and descent.
``margin_left``
Left paragraph margin, in pixels.
``margin_right``
Right paragraph margin, in pixels.
``margin_top``
Margin above paragraph, in pixels.
``margin_bottom``
Margin below paragraph, in pixels. Adjacent margins do not collapse.
``tab_stops``
List of horizontal tab stops, in pixels, measured from the left edge of
the text layout. Defaults to the empty list. When the tab stops
are exhausted, they implicitly continue at 50 pixel intervals.
``wrap``
Boolean. If True (the default), text wraps within the width of the layout.
Other attributes can be used to store additional style information within the
document; it will be ignored by the built-in text classes.
All style attributes (including those not present in a document) default to
``None`` (including the so-called "boolean" styles listed above). The meaning
of a ``None`` style is style- and application-dependent.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import re
import sys
from pyglet import event
from pyglet.text import runlist
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
#: The style attribute takes on multiple values in the document.
STYLE_INDETERMINATE = 'indeterminate'
class InlineElement(object):
'''Arbitrary inline element positioned within a formatted document.
Elements behave like a single glyph in the document. They are
measured by their horizontal advance, ascent above the baseline, and
descent below the baseline.
The pyglet layout classes reserve space in the layout for elements and
call the element's methods to ensure they are rendered at the
appropriate position.
If the size of a element (any of the `advance`, `ascent`, or `descent`
instance variables) is modified it is the application's responsibility to
trigger a reflow of the appropriate area in the affected layouts. This
can be done by forcing a style change over the element's position.
:Ivariables:
`ascent` : int
Ascent of the element above the baseline, in pixels.
`descent` : int
Descent of the element below the baseline, in pixels.
Typically negative.
`advance` : int
Width of the element, in pixels.
'''
def __init__(self, ascent, descent, advance):
self.ascent = ascent
self.descent = descent
self.advance = advance
self._position = None
position = property(lambda self: self._position,
doc='''Position of the element within the
document. Read-only.
:type: int
''')
def place(self, layout, x, y):
'''Construct an instance of the element at the given coordinates.
Called when the element's position within a layout changes, either
due to the initial condition, changes in the document or changes in
the layout size.
It is the responsibility of the element to clip itself against
the layout boundaries, and position itself appropriately with respect
to the layout's position and viewport offset.
The `TextLayout.top_state` graphics state implements this transform
and clipping into window space.
:Parameters:
`layout` : `pyglet.text.layout.TextLayout`
The layout the element moved within.
`x` : int
Position of the left edge of the element, relative
to the left edge of the document, in pixels.
`y` : int
Position of the baseline, relative to the top edge of the
document, in pixels. Note that this is typically negative.
'''
raise NotImplementedError('abstract')
def remove(self, layout):
'''Remove this element from a layout.
The counterpart of `place`; called when the element is no longer
visible in the given layout.
:Parameters:
`layout` : `pyglet.text.layout.TextLayout`
The layout the element was removed from.
'''
raise NotImplementedError('abstract')
class AbstractDocument(event.EventDispatcher):
'''Abstract document interface used by all `pyglet.text` classes.
This class can be overridden to interface pyglet with a third-party
document format. It may be easier to implement the document format in
terms of one of the supplied concrete classes `FormattedDocument` or
`UnformattedDocument`.
'''
_previous_paragraph_re = re.compile(u'\n[^\n\u2029]*$')
_next_paragraph_re = re.compile(u'[\n\u2029]')
def __init__(self, text=''):
super(AbstractDocument, self).__init__()
self._text = u''
self._elements = []
if text:
self.insert_text(0, text)
def _get_text(self):
return self._text
def _set_text(self, text):
if text == self._text:
return
self.delete_text(0, len(self._text))
self.insert_text(0, text)
text = property(_get_text, _set_text,
doc='''Document text.
For efficient incremental updates, use the `insert_text` and
`delete_text` methods instead of replacing this property.
:type: str
''')
def get_paragraph_start(self, pos):
'''Get the starting position of a paragraph.
:Parameters:
`pos` : int
Character position within paragraph.
:rtype: int
'''
# Tricky special case where the $ in pattern matches before the \n at
# the end of the string instead of the end of the string.
if (self._text[:pos + 1].endswith('\n') or
self._text[:pos + 1].endswith(u'\u2029')):
return pos
m = self._previous_paragraph_re.search(self._text, 0, pos + 1)
if not m:
return 0
return m.start() + 1
def get_paragraph_end(self, pos):
'''Get the end position of a paragraph.
:Parameters:
`pos` : int
Character position within paragraph.
:rtype: int
'''
m = self._next_paragraph_re.search(self._text, pos)
if not m:
return len(self._text)
return m.start() + 1
def get_style_runs(self, attribute):
'''Get a style iterator over the given style attribute.
:Parameters:
`attribute` : str
Name of style attribute to query.
:rtype: `AbstractRunIterator`
'''
raise NotImplementedError('abstract')
def get_style(self, attribute, position=0):
'''Get an attribute style at the given position.
:Parameters:
`attribute` : str
Name of style attribute to query.
`position` : int
Character position of document to query.
:return: The style set for the attribute at the given position.
'''
raise NotImplementedError('abstract')
def get_style_range(self, attribute, start, end):
'''Get an attribute style over the given range.
If the style varies over the range, `STYLE_INDETERMINATE` is returned.
:Parameters:
`attribute` : str
Name of style attribute to query.
`start` : int
Starting character position.
`end` : int
Ending character position (exclusive).
:return: The style set for the attribute over the given range, or
`STYLE_INDETERMINATE` if more than one value is set.
'''
iter = self.get_style_runs(attribute)
_, value_end, value = iter.ranges(start, end).next()
if value_end < end:
return STYLE_INDETERMINATE
else:
return value
def get_font_runs(self, dpi=None):
'''Get a style iterator over the `pyglet.font.Font` instances used in
the document.
The font instances are created on-demand by inspection of the
``font_name``, ``font_size``, ``bold`` and ``italic`` style
attributes.
:Parameters:
`dpi` : float
Optional resolution to construct fonts at. See
`pyglet.font.load`.
:rtype: `AbstractRunIterator`
'''
raise NotImplementedError('abstract')
def get_font(self, position, dpi=None):
'''Get the font instance used at the given position.
:see: `get_font_runs`
:Parameters:
`position` : int
Character position of document to query.
`dpi` : float
Optional resolution to construct fonts at. See
`pyglet.font.load`.
:rtype: `pyglet.font.Font`
:return: The font at the given position.
'''
raise NotImplementedError('abstract')
def insert_text(self, start, text, attributes=None):
'''Insert text into the document.
:Parameters:
`start` : int
Character insertion point within document.
`text` : str
Text to insert.
`attributes` : dict
Optional dictionary giving named style attributes of the
inserted text.
'''
self._insert_text(start, text, attributes)
self.dispatch_event('on_insert_text', start, text)
def _insert_text(self, start, text, attributes):
self._text = u''.join((self._text[:start], text, self._text[start:]))
len_text = len(text)
for element in self._elements:
if element._position >= start:
element._position += len_text
def delete_text(self, start, end):
'''Delete text from the document.
:Parameters:
`start` : int
Starting character position to delete from.
`end` : int
Ending character position to delete to (exclusive).
'''
self._delete_text(start, end)
self.dispatch_event('on_delete_text', start, end)
def _delete_text(self, start, end):
for element in list(self._elements):
if start <= element._position < end:
self._elements.remove(element)
elif element._position >= end: # fix bug 538
element._position -= (end - start)
self._text = self._text[:start] + self._text[end:]
def insert_element(self, position, element, attributes=None):
'''Insert a element into the document.
See the `InlineElement` class documentation for details of
usage.
:Parameters:
`position` : int
Character insertion point within document.
`element` : `InlineElement`
Element to insert.
`attributes` : dict
Optional dictionary giving named style attributes of the
inserted text.
'''
assert element._position is None, \
'Element is already in a document.'
self.insert_text(position, '\0', attributes)
element._position = position
self._elements.append(element)
self._elements.sort(key=lambda d:d.position)
def get_element(self, position):
'''Get the element at a specified position.
:Parameters:
`position` : int
Position in the document of the element.
:rtype: `InlineElement`
'''
for element in self._elements:
if element._position == position:
return element
raise RuntimeError('No element at position %d' % position)
def set_style(self, start, end, attributes):
'''Set text style of some or all of the document.
:Parameters:
`start` : int
Starting character position.
`end` : int
Ending character position (exclusive).
`attributes` : dict
Dictionary giving named style attributes of the text.
'''
self._set_style(start, end, attributes)
self.dispatch_event('on_style_text', start, end, attributes)
def _set_style(self, start, end, attributes):
raise NotImplementedError('abstract')
def set_paragraph_style(self, start, end, attributes):
'''Set the style for a range of paragraphs.
This is a convenience method for `set_style` that aligns the
character range to the enclosing paragraph(s).
:Parameters:
`start` : int
Starting character position.
`end` : int
Ending character position (exclusive).
`attributes` : dict
Dictionary giving named style attributes of the paragraphs.
'''
start = self.get_paragraph_start(start)
end = self.get_paragraph_end(end)
self._set_style(start, end, attributes)
self.dispatch_event('on_style_text', start, end, attributes)
if _is_epydoc:
def on_insert_text(self, start, text):
'''Text was inserted into the document.
:Parameters:
`start` : int
Character insertion point within document.
`text` : str
The text that was inserted.
:event:
'''
def on_delete_text(self, start, end):
'''Text was deleted from the document.
:Parameters:
`start` : int
Starting character position of deleted text.
`end` : int
Ending character position of deleted text (exclusive).
:event:
'''
def on_style_text(self, start, end, attributes):
'''Text character style was modified.
:Parameters:
`start` : int
Starting character position of modified text.
`end` : int
Ending character position of modified text (exclusive).
`attributes` : dict
Dictionary giving updated named style attributes of the
text.
:event:
'''
AbstractDocument.register_event_type('on_insert_text')
AbstractDocument.register_event_type('on_delete_text')
AbstractDocument.register_event_type('on_style_text')
class UnformattedDocument(AbstractDocument):
'''A document having uniform style over all text.
Changes to the style of text within the document affects the entire
document. For convenience, the ``position`` parameters of the style
methods may therefore be omitted.
'''
def __init__(self, text=''):
super(UnformattedDocument, self).__init__(text)
self.styles = {}
def get_style_runs(self, attribute):
value = self.styles.get(attribute)
return runlist.ConstRunIterator(len(self.text), value)
def get_style(self, attribute, position=None):
return self.styles.get(attribute)
def set_style(self, start, end, attributes):
return super(UnformattedDocument, self).set_style(
0, len(self.text), attributes)
def _set_style(self, start, end, attributes):
self.styles.update(attributes)
def set_paragraph_style(self, start, end, attributes):
return super(UnformattedDocument, self).set_paragraph_style(
0, len(self.text), attributes)
def get_font_runs(self, dpi=None):
ft = self.get_font(dpi=dpi)
return runlist.ConstRunIterator(len(self.text), ft)
def get_font(self, position=None, dpi=None):
from pyglet import font
font_name = self.styles.get('font_name')
font_size = self.styles.get('font_size')
bold = self.styles.get('bold', False)
italic = self.styles.get('italic', False)
return font.load(font_name, font_size,
bold=bool(bold), italic=bool(italic), dpi=dpi)
def get_element_runs(self):
return runlist.ConstRunIterator(len(self._text), None)
class FormattedDocument(AbstractDocument):
'''Simple implementation of a document that maintains text formatting.
Changes to text style are applied according to the description in
`AbstractDocument`. All styles default to ``None``.
'''
def __init__(self, text=''):
self._style_runs = {}
super(FormattedDocument, self).__init__(text)
def get_style_runs(self, attribute):
try:
return self._style_runs[attribute].get_run_iterator()
except KeyError:
return _no_style_range_iterator
def get_style(self, attribute, position=0):
try:
return self._style_runs[attribute][position]
except KeyError:
return None
def _set_style(self, start, end, attributes):
for attribute, value in attributes.items():
try:
runs = self._style_runs[attribute]
except KeyError:
runs = self._style_runs[attribute] = runlist.RunList(0, None)
runs.insert(0, len(self._text))
runs.set_run(start, end, value)
def get_font_runs(self, dpi=None):
return _FontStyleRunsRangeIterator(
self.get_style_runs('font_name'),
self.get_style_runs('font_size'),
self.get_style_runs('bold'),
self.get_style_runs('italic'),
dpi)
def get_font(self, position, dpi=None):
iter = self.get_font_runs(dpi)
return iter[position]
def get_element_runs(self):
return _ElementIterator(self._elements, len(self._text))
def _insert_text(self, start, text, attributes):
super(FormattedDocument, self)._insert_text(start, text, attributes)
len_text = len(text)
for runs in self._style_runs.values():
runs.insert(start, len_text)
if attributes is not None:
for attribute, value in attributes.items():
try:
runs = self._style_runs[attribute]
except KeyError:
runs = self._style_runs[attribute] = \
runlist.RunList(0, None)
runs.insert(0, len(self.text))
runs.set_run(start, start + len_text, value)
def _delete_text(self, start, end):
super(FormattedDocument, self)._delete_text(start, end)
for runs in self._style_runs.values():
runs.delete(start, end)
def _iter_elements(elements, length):
last = 0
for element in elements:
p = element.position
yield last, p, None
yield p, p + 1, element
last = p + 1
yield last, length, None
class _ElementIterator(runlist.RunIterator):
def __init__(self, elements, length):
self._run_list_iter = _iter_elements(elements, length)
self.start, self.end, self.value = self.next()
class _FontStyleRunsRangeIterator(object):
# XXX subclass runlist
def __init__(self, font_names, font_sizes, bolds, italics, dpi):
self.zip_iter = runlist.ZipRunIterator(
(font_names, font_sizes, bolds, italics))
self.dpi = dpi
def ranges(self, start, end):
from pyglet import font
for start, end, styles in self.zip_iter.ranges(start, end):
font_name, font_size, bold, italic = styles
ft = font.load(font_name, font_size,
bold=bool(bold), italic=bool(italic),
dpi=self.dpi)
yield start, end, ft
def __getitem__(self, index):
from pyglet import font
font_name, font_size, bold, italic = self.zip_iter[index]
return font.load(font_name, font_size,
bold=bool(bold), italic=bool(italic),
dpi=self.dpi)
class _NoStyleRangeIterator(object):
# XXX subclass runlist
def ranges(self, start, end):
yield start, end, None
def __getitem__(self, index):
return None
_no_style_range_iterator = _NoStyleRangeIterator()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''pyglet is a cross-platform games and multimedia package.
Detailed documentation is available at http://www.pyglet.org
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import os
import sys
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
#: The release version of this pyglet installation.
#:
#: Valid only if pyglet was installed from a source or binary distribution
#: (i.e. not in a checked-out copy from SVN).
#:
#: Use setuptools if you need to check for a specific release version, e.g.::
#:
#: >>> import pyglet
#: >>> from pkg_resources import parse_version
#: >>> parse_version(pyglet.version) >= parse_version('1.1')
#: True
#:
version = '1.2alpha1'
# Pyglet platform treats *BSD systems as Linux
compat_platform = sys.platform
if "bsd" in compat_platform:
compat_platform = "linux-compat"
def _require_ctypes_version(version):
# Check ctypes version
import ctypes
req = [int(i) for i in version.split('.')]
have = [int(i) for i in ctypes.__version__.split('.')]
if not tuple(have) >= tuple(req):
raise ImportError('pyglet requires ctypes %s or later.' % version)
_require_ctypes_version('1.0.0')
_enable_optimisations = not __debug__
if getattr(sys, 'frozen', None):
_enable_optimisations = True
#: Global dict of pyglet options. To change an option from its default, you
#: must import ``pyglet`` before any sub-packages. For example::
#:
#: import pyglet
#: pyglet.options['debug_gl'] = False
#:
#: The default options can be overridden from the OS environment. The
#: corresponding environment variable for each option key is prefaced by
#: ``PYGLET_``. For example, in Bash you can set the ``debug_gl`` option with::
#:
#: PYGLET_DEBUG_GL=True; export PYGLET_DEBUG_GL
#:
#: For options requiring a tuple of values, separate each value with a comma.
#:
#: The non-development options are:
#:
#: audio
#: A sequence of the names of audio modules to attempt to load, in
#: order of preference. Valid driver names are:
#:
#: * directsound, the Windows DirectSound audio module (Windows only)
#: * pulse, the PulseAudio module (Linux only)
#: * openal, the OpenAL audio module
#: * silent, no audio
#: debug_lib
#: If True, prints the path of each dynamic library loaded.
#: debug_gl
#: If True, all calls to OpenGL functions are checked afterwards for
#: errors using ``glGetError``. This will severely impact performance,
#: but provides useful exceptions at the point of failure. By default,
#: this option is enabled if ``__debug__`` is (i.e., if Python was not run
#: with the -O option). It is disabled by default when pyglet is "frozen"
#: within a py2exe or py2app library archive.
#: shadow_window
#: By default, pyglet creates a hidden window with a GL context when
#: pyglet.gl is imported. This allows resources to be loaded before
#: the application window is created, and permits GL objects to be
#: shared between windows even after they've been closed. You can
#: disable the creation of the shadow window by setting this option to
#: False.
#:
#: Some OpenGL driver implementations may not support shared OpenGL
#: contexts and may require disabling the shadow window (and all resources
#: must be loaded after the window using them was created). Recommended
#: for advanced developers only.
#:
#: **Since:** pyglet 1.1
#: vsync
#: If set, the `pyglet.window.Window.vsync` property is ignored, and
#: this option overrides it (to either force vsync on or off). If unset,
#: or set to None, the `pyglet.window.Window.vsync` property behaves
#: as documented.
#: xsync
#: If set (the default), pyglet will attempt to synchronise the drawing of
#: double-buffered windows to the border updates of the X11 window
#: manager. This improves the appearance of the window during resize
#: operations. This option only affects double-buffered windows on
#: X11 servers supporting the Xsync extension with a window manager
#: that implements the _NET_WM_SYNC_REQUEST protocol.
#:
#: **Since:** pyglet 1.1
#: darwin_cocoa
#: If True, the Cocoa-based pyglet implementation is used as opposed to
#: the 32-bit Carbon implementation. When python is running in 64-bit mode
#: on Mac OS X 10.6 or later, this option is set to True by default.
#: Otherwise the Carbon implementation is preferred.
#:
#: **Since:** pyglet 1.2
#:
#: search_local_libs
#: If False, pyglet won't try to search for libraries in the script
#: directory and its `lib` subdirectory. This is useful to load a local
#: library instead of the system installed version. This option is set
#: to True by default.
#:
#: **Since:** pyglet 1.2
#:
options = {
'audio': ('directsound', 'pulse', 'openal', 'silent'),
'font': ('gdiplus', 'win32'), # ignored outside win32; win32 is deprecated
'debug_font': False,
'debug_gl': not _enable_optimisations,
'debug_gl_trace': False,
'debug_gl_trace_args': False,
'debug_graphics_batch': False,
'debug_lib': False,
'debug_media': False,
'debug_texture': False,
'debug_trace': False,
'debug_trace_args': False,
'debug_trace_depth': 1,
'debug_trace_flush': True,
'debug_win32': False,
'debug_x11': False,
'graphics_vbo': True,
'shadow_window': True,
'vsync': None,
'xsync': True,
'xlib_fullscreen_override_redirect': False,
'darwin_cocoa': False,
'search_local_libs': True,
}
_option_types = {
'audio': tuple,
'font': tuple,
'debug_font': bool,
'debug_gl': bool,
'debug_gl_trace': bool,
'debug_gl_trace_args': bool,
'debug_graphics_batch': bool,
'debug_lib': bool,
'debug_media': bool,
'debug_texture': bool,
'debug_trace': bool,
'debug_trace_args': bool,
'debug_trace_depth': int,
'debug_trace_flush': bool,
'debug_win32': bool,
'debug_x11': bool,
'graphics_vbo': bool,
'shadow_window': bool,
'vsync': bool,
'xsync': bool,
'xlib_fullscreen_override_redirect': bool,
'darwin_cocoa': bool,
}
def _choose_darwin_platform():
"""Choose between Darwin's Carbon and Cocoa implementations."""
if compat_platform != 'darwin':
return
import struct
numbits = 8*struct.calcsize("P")
if numbits == 64:
import platform
osx_version = platform.mac_ver()[0].split(".")
if int(osx_version[0]) == 10 and int(osx_version[1]) < 6:
raise Exception('pyglet is not compatible with 64-bit Python for versions of Mac OS X prior to 10.6.')
options['darwin_cocoa'] = True
else:
options['darwin_cocoa'] = False
_choose_darwin_platform() # can be overridden by an environment variable below
def _read_environment():
'''Read defaults for options from environment'''
for key in options:
env = 'PYGLET_%s' % key.upper()
try:
value = os.environ[env]
if _option_types[key] is tuple:
options[key] = value.split(',')
elif _option_types[key] is bool:
options[key] = value in ('true', 'TRUE', 'True', '1')
elif _option_types[key] is int:
options[key] = int(value)
except KeyError:
pass
_read_environment()
if compat_platform == 'cygwin':
# This hack pretends that the posix-like ctypes provides windows
# functionality. COM does not work with this hack, so there is no
# DirectSound support.
import ctypes
ctypes.windll = ctypes.cdll
ctypes.oledll = ctypes.cdll
ctypes.WINFUNCTYPE = ctypes.CFUNCTYPE
ctypes.HRESULT = ctypes.c_long
# Call tracing
# ------------
_trace_filename_abbreviations = {}
def _trace_repr(value, size=40):
value = repr(value)
if len(value) > size:
value = value[:size//2-2] + '...' + value[-size//2-1:]
return value
def _trace_frame(thread, frame, indent):
from pyglet import lib
if frame.f_code is lib._TraceFunction.__call__.func_code:
is_ctypes = True
func = frame.f_locals['self']._func
name = func.__name__
location = '[ctypes]'
else:
is_ctypes = False
code = frame.f_code
name = code.co_name
path = code.co_filename
line = code.co_firstlineno
try:
filename = _trace_filename_abbreviations[path]
except KeyError:
# Trim path down
dir = ''
path, filename = os.path.split(path)
while len(dir + filename) < 30:
filename = os.path.join(dir, filename)
path, dir = os.path.split(path)
if not dir:
filename = os.path.join('', filename)
break
else:
filename = os.path.join('...', filename)
_trace_filename_abbreviations[path] = filename
location = '(%s:%d)' % (filename, line)
if indent:
name = 'Called from %s' % name
print '[%d] %s%s %s' % (thread, indent, name, location)
if _trace_args:
if is_ctypes:
args = [_trace_repr(arg) for arg in frame.f_locals['args']]
print ' %sargs=(%s)' % (indent, ', '.join(args))
else:
for argname in code.co_varnames[:code.co_argcount]:
try:
argvalue = _trace_repr(frame.f_locals[argname])
print ' %s%s=%s' % (indent, argname, argvalue)
except:
pass
if _trace_flush:
sys.stdout.flush()
def _thread_trace_func(thread):
def _trace_func(frame, event, arg):
if event == 'call':
indent = ''
for i in range(_trace_depth):
_trace_frame(thread, frame, indent)
indent += ' '
frame = frame.f_back
if not frame:
break
elif event == 'exception':
(exception, value, traceback) = arg
print 'First chance exception raised:', repr(exception)
return _trace_func
def _install_trace():
global _trace_thread_count
sys.setprofile(_thread_trace_func(_trace_thread_count))
_trace_thread_count += 1
_trace_thread_count = 0
_trace_args = options['debug_trace_args']
_trace_depth = options['debug_trace_depth']
_trace_flush = options['debug_trace_flush']
if options['debug_trace']:
_install_trace()
# Lazy loading
# ------------
class _ModuleProxy(object):
_module = None
def __init__(self, name):
self.__dict__['_module_name'] = name
def __getattr__(self, name):
try:
return getattr(self._module, name)
except AttributeError:
if self._module is not None:
raise
import_name = 'pyglet.%s' % self._module_name
__import__(import_name)
module = sys.modules[import_name]
object.__setattr__(self, '_module', module)
globals()[self._module_name] = module
return getattr(module, name)
def __setattr__(self, name, value):
try:
setattr(self._module, name, value)
except AttributeError:
if self._module is not None:
raise
import_name = 'pyglet.%s' % self._module_name
__import__(import_name)
module = sys.modules[import_name]
object.__setattr__(self, '_module', module)
globals()[self._module_name] = module
setattr(module, name, value)
if True:
app = _ModuleProxy('app')
canvas = _ModuleProxy('canvas')
clock = _ModuleProxy('clock')
com = _ModuleProxy('com')
event = _ModuleProxy('event')
font = _ModuleProxy('font')
gl = _ModuleProxy('gl')
graphics = _ModuleProxy('graphics')
image = _ModuleProxy('image')
input = _ModuleProxy('input')
lib = _ModuleProxy('lib')
media = _ModuleProxy('media')
resource = _ModuleProxy('resource')
sprite = _ModuleProxy('sprite')
text = _ModuleProxy('text')
window = _ModuleProxy('window')
# Fool py2exe, py2app into including all top-level modules (doesn't understand
# lazy loading)
if False:
import app
import canvas
import clock
import com
import event
import font
import gl
import graphics
import input
import image
import lib
import media
import resource
import sprite
import text
import window
# Hack around some epydoc bug that causes it to think pyglet.window is None.
if False:
import window
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from ctypes import *
import ctypes
from pyglet import app
from pyglet.app.xlib import XlibSelectDevice
from base import Display, Screen, ScreenMode, Canvas
import xlib_vidmoderestore
# XXX
#from pyglet.window import NoSuchDisplayException
class NoSuchDisplayException(Exception):
pass
from pyglet.libs.x11 import xlib
try:
from pyglet.libs.x11 import xinerama
_have_xinerama = True
except:
_have_xinerama = False
try:
from pyglet.libs.x11 import xsync
_have_xsync = True
except:
_have_xsync = False
try:
from pyglet.libs.x11 import xf86vmode
_have_xf86vmode = True
except:
_have_xf86vmode = False
# Set up error handler
def _error_handler(display, event):
# By default, all errors are silently ignored: this has a better chance
# of working than the default behaviour of quitting ;-)
#
# We've actually never seen an error that was our fault; they're always
# driver bugs (and so the reports are useless). Nevertheless, set
# environment variable PYGLET_DEBUG_X11 to 1 to get dumps of the error
# and a traceback (execution will continue).
import pyglet
if pyglet.options['debug_x11']:
event = event.contents
buf = c_buffer(1024)
xlib.XGetErrorText(display, event.error_code, buf, len(buf))
print 'X11 error:', buf.value
print ' serial:', event.serial
print ' request:', event.request_code
print ' minor:', event.minor_code
print ' resource:', event.resourceid
import traceback
print 'Python stack trace (innermost last):'
traceback.print_stack()
return 0
_error_handler_ptr = xlib.XErrorHandler(_error_handler)
xlib.XSetErrorHandler(_error_handler_ptr)
class XlibDisplay(XlibSelectDevice, Display):
_display = None # POINTER(xlib.Display)
_x_im = None # X input method
# TODO close _x_im when display connection closed.
_enable_xsync = False
_screens = None # Cache of get_screens()
def __init__(self, name=None, x_screen=None):
if x_screen is None:
x_screen = 0
self._display = xlib.XOpenDisplay(name)
if not self._display:
raise NoSuchDisplayException('Cannot connect to "%s"' % name)
screen_count = xlib.XScreenCount(self._display)
if x_screen >= screen_count:
raise NoSuchDisplayException(
'Display "%s" has no screen %d' % (name, x_screen))
super(XlibDisplay, self).__init__()
self.name = name
self.x_screen = x_screen
self._fileno = xlib.XConnectionNumber(self._display)
self._window_map = {}
# Initialise XSync
if _have_xsync:
event_base = c_int()
error_base = c_int()
if xsync.XSyncQueryExtension(self._display,
byref(event_base),
byref(error_base)):
major_version = c_int()
minor_version = c_int()
if xsync.XSyncInitialize(self._display,
byref(major_version),
byref(minor_version)):
self._enable_xsync = True
# Add to event loop select list. Assume we never go away.
app.platform_event_loop._select_devices.add(self)
def get_screens(self):
if self._screens:
return self._screens
if _have_xinerama and xinerama.XineramaIsActive(self._display):
number = c_int()
infos = xinerama.XineramaQueryScreens(self._display,
byref(number))
infos = cast(infos,
POINTER(xinerama.XineramaScreenInfo * number.value)).contents
self._screens = []
using_xinerama = number.value > 1
for info in infos:
self._screens.append(XlibScreen(self,
info.x_org,
info.y_org,
info.width,
info.height,
using_xinerama))
xlib.XFree(infos)
else:
# No xinerama
screen_info = xlib.XScreenOfDisplay(self._display, self.x_screen)
screen = XlibScreen(self,
0, 0,
screen_info.contents.width,
screen_info.contents.height,
False)
self._screens = [screen]
return self._screens
# XlibSelectDevice interface
def fileno(self):
return self._fileno
def select(self):
e = xlib.XEvent()
while xlib.XPending(self._display):
xlib.XNextEvent(self._display, e)
# Key events are filtered by the xlib window event
# handler so they get a shot at the prefiltered event.
if e.xany.type not in (xlib.KeyPress, xlib.KeyRelease):
if xlib.XFilterEvent(e, e.xany.window):
continue
try:
dispatch = self._window_map[e.xany.window]
except KeyError:
continue
dispatch(e)
def poll(self):
return xlib.XPending(self._display)
class XlibScreen(Screen):
_initial_mode = None
def __init__(self, display, x, y, width, height, xinerama):
super(XlibScreen, self).__init__(display, x, y, width, height)
self._xinerama = xinerama
def get_matching_configs(self, template):
canvas = XlibCanvas(self.display, None)
configs = template.match(canvas)
# XXX deprecate
for config in configs:
config.screen = self
return configs
def get_modes(self):
if not _have_xf86vmode:
return []
if self._xinerama:
# If Xinerama/TwinView is enabled, xf86vidmode's modelines
# correspond to metamodes, which don't distinguish one screen from
# another. XRandR (broken) or NV (complicated) extensions needed.
return []
count = ctypes.c_int()
info_array = \
ctypes.POINTER(ctypes.POINTER(xf86vmode.XF86VidModeModeInfo))()
xf86vmode.XF86VidModeGetAllModeLines(
self.display._display, self.display.x_screen, count, info_array)
# Copy modes out of list and free list
modes = []
for i in range(count.value):
info = xf86vmode.XF86VidModeModeInfo()
ctypes.memmove(ctypes.byref(info),
ctypes.byref(info_array.contents[i]),
ctypes.sizeof(info))
modes.append(XlibScreenMode(self, info))
if info.privsize:
xlib.XFree(info.private)
xlib.XFree(info_array)
return modes
def get_mode(self):
modes = self.get_modes()
if modes:
return modes[0]
return None
def set_mode(self, mode):
assert mode.screen is self
if not self._initial_mode:
self._initial_mode = self.get_mode()
xlib_vidmoderestore.set_initial_mode(self._initial_mode)
xf86vmode.XF86VidModeSwitchToMode(self.display._display,
self.display.x_screen, mode.info)
xlib.XFlush(self.display._display)
xf86vmode.XF86VidModeSetViewPort(self.display._display,
self.display.x_screen, 0, 0)
xlib.XFlush(self.display._display)
self.width = mode.width
self.height = mode.height
def restore_mode(self):
if self._initial_mode:
self.set_mode(self._initial_mode)
def __repr__(self):
return 'XlibScreen(display=%r, x=%d, y=%d, ' \
'width=%d, height=%d, xinerama=%d)' % \
(self.display, self.x, self.y, self.width, self.height,
self._xinerama)
class XlibScreenMode(ScreenMode):
def __init__(self, screen, info):
super(XlibScreenMode, self).__init__(screen)
self.info = info
self.width = info.hdisplay
self.height = info.vdisplay
self.rate = info.dotclock
self.depth = None
class XlibCanvas(Canvas):
def __init__(self, display, x_window):
super(XlibCanvas, self).__init__(display)
self.x_window = x_window
| Python |
# Note: The display mode API used here is Mac OS 10.6 only.
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from ctypes import *
from ctypes import util
from pyglet import app
from base import Display, Screen, ScreenMode, Canvas
from pyglet.libs.darwin.cocoapy import *
class CocoaDisplay(Display):
def get_screens(self):
maxDisplays = 256
activeDisplays = (CGDirectDisplayID * maxDisplays)()
count = c_uint32()
quartz.CGGetActiveDisplayList(maxDisplays, activeDisplays, byref(count))
return [CocoaScreen(self, displayID) for displayID in list(activeDisplays)[:count.value]]
class CocoaScreen(Screen):
def __init__(self, display, displayID):
bounds = quartz.CGDisplayBounds(displayID)
# FIX ME:
# Probably need to convert the origin coordinates depending on context:
# http://www.cocoabuilder.com/archive/cocoa/233492-ns-cg-rect-conversion-and-screen-coordinates.html
x, y = bounds.origin.x, bounds.origin.y
width, height = bounds.size.width, bounds.size.height
super(CocoaScreen, self).__init__(display, int(x), int(y), int(width), int(height))
self._cg_display_id = displayID
# Save the default mode so we can restore to it.
self._default_mode = self.get_mode()
# FIX ME:
# This method is needed to get multi-monitor support working properly.
# However the NSScreens.screens() message currently sends out a warning:
# "*** -[NSLock unlock]: lock (<NSLock: 0x...> '(null)') unlocked when not locked"
# on Snow Leopard and apparently causes python to crash on Lion.
#
# def get_nsscreen(self):
# """Returns the NSScreen instance that matches our CGDirectDisplayID."""
# NSScreen = ObjCClass('NSScreen')
# # Get a list of all currently active NSScreens and then search through
# # them until we find one that matches our CGDisplayID.
# screen_array = NSScreen.screens()
# count = screen_array.count()
# for i in range(count):
# nsscreen = screen_array.objectAtIndex_(i)
# screenInfo = nsscreen.deviceDescription()
# displayID = screenInfo.objectForKey_(get_NSString('NSScreenNumber'))
# displayID = displayID.intValue()
# if displayID == self._cg_display_id:
# return nsscreen
# return None
def get_matching_configs(self, template):
canvas = CocoaCanvas(self.display, self, None)
return template.match(canvas)
def get_modes(self):
cgmodes = c_void_p(quartz.CGDisplayCopyAllDisplayModes(self._cg_display_id, None))
modes = [ CocoaScreenMode(self, cgmode) for cgmode in cfarray_to_list(cgmodes) ]
cf.CFRelease(cgmodes)
return modes
def get_mode(self):
cgmode = c_void_p(quartz.CGDisplayCopyDisplayMode(self._cg_display_id))
mode = CocoaScreenMode(self, cgmode)
quartz.CGDisplayModeRelease(cgmode)
return mode
def set_mode(self, mode):
assert mode.screen is self
quartz.CGDisplayCapture(self._cg_display_id)
quartz.CGDisplaySetDisplayMode(self._cg_display_id, mode.cgmode, None)
self.width = mode.width
self.height = mode.height
def restore_mode(self):
quartz.CGDisplaySetDisplayMode(self._cg_display_id, self._default_mode.cgmode, None)
quartz.CGDisplayRelease(self._cg_display_id)
def capture_display(self):
quartz.CGDisplayCapture(self._cg_display_id)
def release_display(self):
quartz.CGDisplayRelease(self._cg_display_id)
class CocoaScreenMode(ScreenMode):
def __init__(self, screen, cgmode):
super(CocoaScreenMode, self).__init__(screen)
quartz.CGDisplayModeRetain(cgmode)
self.cgmode = cgmode
self.width = int(quartz.CGDisplayModeGetWidth(cgmode))
self.height = int(quartz.CGDisplayModeGetHeight(cgmode))
self.depth = self.getBitsPerPixel(cgmode)
self.rate = quartz.CGDisplayModeGetRefreshRate(cgmode)
def __del__(self):
quartz.CGDisplayModeRelease(self.cgmode)
self.cgmode = None
def getBitsPerPixel(self, cgmode):
# from /System/Library/Frameworks/IOKit.framework/Headers/graphics/IOGraphicsTypes.h
IO8BitIndexedPixels = "PPPPPPPP"
IO16BitDirectPixels = "-RRRRRGGGGGBBBBB"
IO32BitDirectPixels = "--------RRRRRRRRGGGGGGGGBBBBBBBB"
cfstring = c_void_p(quartz.CGDisplayModeCopyPixelEncoding(cgmode))
pixelEncoding = cfstring_to_string(cfstring)
cf.CFRelease(cfstring)
if pixelEncoding == IO8BitIndexedPixels: return 8
if pixelEncoding == IO16BitDirectPixels: return 16
if pixelEncoding == IO32BitDirectPixels: return 32
return 0
class CocoaCanvas(Canvas):
def __init__(self, display, screen, nsview):
super(CocoaCanvas, self).__init__(display)
self.screen = screen
self.nsview = nsview
| Python |
#!/usr/bin/python
# $Id:$
from pyglet import app
from pyglet import gl
from pyglet import window
class Display(object):
'''A display device supporting one or more screens.
:guide:`displays`
:since: pyglet 1.2
'''
name = None
'''Name of this display, if applicable.
:type: str
'''
x_screen = None
'''The X11 screen number of this display, if applicable.
:type: int
'''
def __init__(self, name=None, x_screen=None):
'''Create a display connection for the given name and screen.
On X11, :attr:`name` is of the form ``"hostname:display"``, where the
default is usually ``":1"``. On X11, :attr:`x_screen` gives the X
screen number to use with this display. A pyglet display can only be
used with one X screen; open multiple display connections to access
multiple X screens.
Note that TwinView, Xinerama, xrandr and other extensions present
multiple monitors on a single X screen; this is usually the preferred
mechanism for working with multiple monitors under X11 and allows each
screen to be accessed through a single pyglet `Display`.
On platforms other than X11, :attr:`name` and :attr:`x_screen` are
ignored; there is only a single display device on these systems.
:Parameters:
`name` : str
The name of the display to connect to.
`x_screen` : int
The X11 screen number to use.
'''
app.displays.add(self)
def get_screens(self):
'''Get the available screens.
A typical multi-monitor workstation comprises one :class:`Display`
with multiple :class:`Screen` s. This method returns a list of
screens which can be enumerated to select one for full-screen display.
For the purposes of creating an OpenGL config, the default screen
will suffice.
:rtype: list of :class:`Screen`
'''
raise NotImplementedError('abstract')
def get_default_screen(self):
'''Get the default screen as specified by the user's operating system
preferences.
:rtype: :class:`Screen`
'''
return self.get_screens()[0]
def get_windows(self):
'''Get the windows currently attached to this display.
:rtype: sequence of :class:`~pyglet.window.Window`
'''
return [window for window in app.windows if window.display is self]
class Screen(object):
'''A virtual monitor that supports fullscreen windows.
Screens typically map onto a physical display such as a
monitor, television or projector. Selecting a screen for a window
has no effect unless the window is made fullscreen, in which case
the window will fill only that particular virtual screen.
The :attr:`width` and :attr:`height` attributes of a screen give the
current resolution of the screen. The :attr:`x` and :attr:`y` attributes
give the global location of the top-left corner of the screen. This is
useful for determining if screens arranged above or next to one another.
Use :func:`~Display.get_screens` or :func:`~Display.get_default_screen`
to obtain an instance of this class.
:guide:`screens`
'''
def __init__(self, display, x, y, width, height):
'''
:parameters:
`display` : `~pyglet.canvas.Display`
:attr:`display`
`x` : int
Left edge :attr:`x`
`y` : int
Top edge :attr:`y`
`width` : int
:attr:`width`
`height` : int
:attr:`height`
'''
self.display = display
'''Display this screen belongs to.'''
self.x = x
'''Left edge of the screen on the virtual desktop.'''
self.y = y
'''Top edge of the screen on the virtual desktop.'''
self.width = width
'''Width of the screen, in pixels.'''
self.height = height
'''Height of the screen, in pixels.'''
def __repr__(self):
return '%s(x=%d, y=%d, width=%d, height=%d)' % \
(self.__class__.__name__, self.x, self.y, self.width, self.height)
def get_best_config(self, template=None):
'''Get the best available GL config.
Any required attributes can be specified in `template`. If
no configuration matches the template,
:class:`~pyglet.window.NoSuchConfigException` will be raised.
:deprecated: Use :meth:`pyglet.gl.Config.match`.
:Parameters:
`template` : `pyglet.gl.Config`
A configuration with desired attributes filled in.
:rtype: :class:`~pyglet.gl.Config`
:return: A configuration supported by the platform that best
fulfils the needs described by the template.
'''
configs = None
if template is None:
for template_config in [
gl.Config(double_buffer=True, depth_size=24),
gl.Config(double_buffer=True, depth_size=16),
None]:
try:
configs = self.get_matching_configs(template_config)
break
except NoSuchConfigException:
pass
else:
configs = self.get_matching_configs(template)
if not configs:
raise window.NoSuchConfigException()
return configs[0]
def get_matching_configs(self, template):
'''Get a list of configs that match a specification.
Any attributes specified in `template` will have values equal
to or greater in each returned config. If no configs satisfy
the template, an empty list is returned.
:deprecated: Use :meth:`pyglet.gl.Config.match`.
:Parameters:
`template` : `pyglet.gl.Config`
A configuration with desired attributes filled in.
:rtype: list of :class:`~pyglet.gl.Config`
:return: A list of matching configs.
'''
raise NotImplementedError('abstract')
def get_modes(self):
'''Get a list of screen modes supported by this screen.
:rtype: list of :class:`ScreenMode`
:since: pyglet 1.2
'''
raise NotImplementedError('abstract')
def get_mode(self):
'''Get the current display mode for this screen.
:rtype: :class:`ScreenMode`
:since: pyglet 1.2
'''
raise NotImplementedError('abstract')
def get_closest_mode(self, width, height):
'''Get the screen mode that best matches a given size.
If no supported mode exactly equals the requested size, a larger one
is returned; or ``None`` if no mode is large enough.
:Parameters:
`width` : int
Requested screen width.
`height` : int
Requested screen height.
:rtype: :class:`ScreenMode`
:since: pyglet 1.2
'''
# Best mode is one with smallest resolution larger than width/height,
# with depth and refresh rate equal to current mode.
current = self.get_mode()
best = None
for mode in self.get_modes():
# Reject resolutions that are too small
if mode.width < width or mode.height < height:
continue
if best is None:
best = mode
# Must strictly dominate dimensions
if (mode.width <= best.width and mode.height <= best.height and
(mode.width < best.width or mode.height < best.height)):
best = mode
# Preferably match rate, then depth.
if mode.width == best.width and mode.height == best.height:
points = 0
if mode.rate == current.rate:
points += 2
if best.rate == current.rate:
points -= 2
if mode.depth == current.depth:
points += 1
if best.depth == current.depth:
points -= 1
if points > 0:
best = mode
return best
def set_mode(self, mode):
'''Set the display mode for this screen.
The mode must be one previously returned by :meth:`get_mode` or
:meth:`get_modes`.
:Parameters:
`mode` : `ScreenMode`
Screen mode to switch this screen to.
'''
raise NotImplementedError('abstract')
def restore_mode(self):
'''Restore the screen mode to the user's default.
'''
raise NotImplementedError('abstract')
class ScreenMode(object):
'''Screen resolution and display settings.
Applications should not construct `ScreenMode` instances themselves; see
:meth:`Screen.get_modes`.
The :attr:`depth` and :attr:`rate` variables may be ``None`` if the
operating system does not provide relevant data.
:since: pyglet 1.2
'''
width = None
'''Width of screen, in pixels.
:type: int
'''
height = None
'''Height of screen, in pixels.
:type: int
'''
depth = None
'''Pixel color depth, in bits per pixel.
:type: int
'''
rate = None
'''Screen refresh rate in Hz.
:type: int
'''
def __init__(self, screen):
'''
:parameters:
`screen` : `Screen`
'''
self.screen = screen
def __repr__(self):
return '%s(width=%r, height=%r, depth=%r, rate=%r)' % (
self.__class__.__name__,
self.width, self.height, self.depth, self.rate)
class Canvas(object):
'''Abstract drawing area.
Canvases are used internally by pyglet to represent drawing areas --
either within a window or full-screen.
:since: pyglet 1.2
'''
def __init__(self, display):
'''
:parameters:
`display` : `Display`
:attr:`display`
'''
self.display = display
'''Display this canvas was created on.'''
| Python |
#!/usr/bin/python
# $Id:$
from base import Display, Screen, ScreenMode, Canvas
from pyglet.libs.win32 import _kernel32, _user32, types, constants
from pyglet.libs.win32.constants import *
from pyglet.libs.win32.types import *
class Win32Display(Display):
def get_screens(self):
screens = []
def enum_proc(hMonitor, hdcMonitor, lprcMonitor, dwData):
r = lprcMonitor.contents
width = r.right - r.left
height = r.bottom - r.top
screens.append(
Win32Screen(self, hMonitor, r.left, r.top, width, height))
return True
enum_proc_ptr = MONITORENUMPROC(enum_proc)
_user32.EnumDisplayMonitors(None, None, enum_proc_ptr, 0)
return screens
class Win32Screen(Screen):
_initial_mode = None
def __init__(self, display, handle, x, y, width, height):
super(Win32Screen, self).__init__(display, x, y, width, height)
self._handle = handle
def get_matching_configs(self, template):
canvas = Win32Canvas(self.display, 0, _user32.GetDC(0))
configs = template.match(canvas)
# XXX deprecate config's being screen-specific
for config in configs:
config.screen = self
return configs
def get_device_name(self):
info = MONITORINFOEX()
info.cbSize = sizeof(MONITORINFOEX)
_user32.GetMonitorInfoW(self._handle, byref(info))
return info.szDevice
def get_modes(self):
device_name = self.get_device_name()
i = 0
modes = []
while True:
mode = DEVMODE()
mode.dmSize = sizeof(DEVMODE)
r = _user32.EnumDisplaySettingsW(device_name, i, byref(mode))
if not r:
break
modes.append(Win32ScreenMode(self, mode))
i += 1
return modes
def get_mode(self):
mode = DEVMODE()
mode.dmSize = sizeof(DEVMODE)
_user32.EnumDisplaySettingsW(self.get_device_name(),
ENUM_CURRENT_SETTINGS,
byref(mode))
return Win32ScreenMode(self, mode)
def set_mode(self, mode):
assert mode.screen is self
if not self._initial_mode:
self._initial_mode = self.get_mode()
r = _user32.ChangeDisplaySettingsExW(self.get_device_name(),
byref(mode._mode),
None,
CDS_FULLSCREEN,
None)
if r == DISP_CHANGE_SUCCESSFUL:
self.width = mode.width
self.height = mode.height
def restore_mode(self):
if self._initial_mode:
self.set_mode(self._initial_mode)
class Win32ScreenMode(ScreenMode):
def __init__(self, screen, mode):
super(Win32ScreenMode, self).__init__(screen)
self._mode = mode
self.width = mode.dmPelsWidth
self.height = mode.dmPelsHeight
self.depth = mode.dmBitsPerPel
self.rate = mode.dmDisplayFrequency
class Win32Canvas(Canvas):
def __init__(self, display, hwnd, hdc):
super(Win32Canvas, self).__init__(display)
self.hwnd = hwnd
self.hdc = hdc
| Python |
#!/usr/bin/python
# $Id: $
'''Fork a child process and inform it of mode changes to each screen. The
child waits until the parent process dies, and then connects to each X server
with a mode change and restores the mode.
This emulates the behaviour of Windows and Mac, so that resolution changes
made by an application are not permanent after the program exits, even if
the process is terminated uncleanly.
The child process is communicated to via a pipe, and watches for parent
death with a Linux extension signal handler.
'''
import ctypes
import os
import signal
import struct
import threading
from pyglet.libs.x11 import xlib
from pyglet.compat import asbytes
try:
from pyglet.libs.x11 import xf86vmode
except:
# No xf86vmode... should not be switching modes.
pass
_restore_mode_child_installed = False
_restorable_screens = set()
_mode_write_pipe = None
# Mode packets tell the child process how to restore a given display and
# screen. Only one packet should be sent per display/screen (more would
# indicate redundancy or incorrect restoration). Packet format is:
# display (max 256 chars),
# screen
# width
# height
# rate
class ModePacket(object):
format = '256siHHI'
size = struct.calcsize(format)
def __init__(self, display, screen, width, height, rate):
self.display = display
self.screen = screen
self.width = width
self.height = height
self.rate = rate
def encode(self):
return struct.pack(self.format, self.display, self.screen,
self.width, self.height, self.rate)
@classmethod
def decode(cls, data):
display, screen, width, height, rate = \
struct.unpack(cls.format, data)
return cls(display.strip(asbytes('\0')), screen, width, height, rate)
def __repr__(self):
return '%s(%r, %r, %r, %r, %r)' % (
self.__class__.__name__, self.display, self.screen,
self.width, self.height, self.rate)
def set(self):
display = xlib.XOpenDisplay(self.display)
modes, n_modes = get_modes_array(display, self.screen)
mode = get_matching_mode(modes, n_modes,
self.width, self.height, self.rate)
if mode is not None:
xf86vmode.XF86VidModeSwitchToMode(display, self.screen, mode)
free_modes_array(modes, n_modes)
xlib.XCloseDisplay(display)
def get_modes_array(display, screen):
count = ctypes.c_int()
modes = ctypes.POINTER(ctypes.POINTER(xf86vmode.XF86VidModeModeInfo))()
xf86vmode.XF86VidModeGetAllModeLines(display, screen, count, modes)
return modes, count.value
def get_matching_mode(modes, n_modes, width, height, rate):
# Copy modes out of list and free list
for i in range(n_modes):
mode = modes.contents[i]
if (mode.hdisplay == width and
mode.vdisplay == height and
mode.dotclock == rate):
return mode
return None
def free_modes_array(modes, n_modes):
for i in range(n_modes):
mode = modes.contents[i]
if mode.privsize:
xlib.XFree(mode.private)
xlib.XFree(modes)
def _install_restore_mode_child():
global _mode_write_pipe
global _restore_mode_child_installed
if _restore_mode_child_installed:
return
# Parent communicates to child by sending "mode packets" through a pipe:
mode_read_pipe, _mode_write_pipe = os.pipe()
if os.fork() == 0:
# Child process (watches for parent to die then restores video mode(s).
os.close(_mode_write_pipe)
# Set up SIGHUP to be the signal for when the parent dies.
PR_SET_PDEATHSIG = 1
libc = ctypes.cdll.LoadLibrary('libc.so.6')
libc.prctl.argtypes = (ctypes.c_int, ctypes.c_ulong, ctypes.c_ulong,
ctypes.c_ulong, ctypes.c_ulong)
libc.prctl(PR_SET_PDEATHSIG, signal.SIGHUP, 0, 0, 0)
# SIGHUP indicates the parent has died. The child lock is unlocked, it
# stops reading from the mode packet pipe and restores video modes on
# all displays/screens it knows about.
def _sighup(signum, frame):
parent_wait_lock.release();
parent_wait_lock = threading.Lock();
parent_wait_lock.acquire()
signal.signal(signal.SIGHUP, _sighup)
# Wait for parent to die and read packets from parent pipe
packets = []
buffer = asbytes('')
while parent_wait_lock.locked():
try:
data = os.read(mode_read_pipe, ModePacket.size)
buffer += data
# Decode packets
while len(buffer) >= ModePacket.size:
packet = ModePacket.decode(buffer[:ModePacket.size])
packets.append(packet)
buffer = buffer[ModePacket.size:]
except OSError:
pass # Interrupted system call
for packet in packets:
packet.set()
os._exit(0)
else:
# Parent process. Clean up pipe then continue running program as
# normal. Send mode packets through pipe as additional
# displays/screens are mode switched.
os.close(mode_read_pipe)
_restore_mode_child_installed = True
def set_initial_mode(mode):
_install_restore_mode_child()
display = xlib.XDisplayString(mode.screen.display._display)
screen = mode.screen.display.x_screen
# Only store one mode per screen.
if (display, screen) in _restorable_screens:
return
packet = ModePacket(display, screen, mode.width, mode.height, mode.rate)
os.write(_mode_write_pipe, packet.encode())
_restorable_screens.add((display, screen))
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
from pyglet import app
from base import Display, Screen, ScreenMode, Canvas
from pyglet.libs.darwin import *
from pyglet.libs.darwin import _oscheck
class CarbonDisplay(Display):
# TODO: CarbonDisplay could be per display device, which would make
# reporting of screens and available configs more accurate. The number of
# Macs with more than one video card is probably small, though.
def __init__(self):
super(CarbonDisplay, self).__init__()
import MacOS
if not MacOS.WMAvailable():
raise app.AppException('Window manager is not available. ' \
'Ensure you run "pythonw", not "python"')
self._install_application_event_handlers()
def get_screens(self):
count = CGDisplayCount()
carbon.CGGetActiveDisplayList(0, None, byref(count))
displays = (CGDirectDisplayID * count.value)()
carbon.CGGetActiveDisplayList(count.value, displays, byref(count))
return [CarbonScreen(self, id) for id in displays]
def _install_application_event_handlers(self):
self._carbon_event_handlers = []
self._carbon_event_handler_refs = []
target = carbon.GetApplicationEventTarget()
# TODO something with a metaclass or hacky like CarbonWindow
# to make this list extensible
handlers = [
(self._on_mouse_down, kEventClassMouse, kEventMouseDown),
(self._on_apple_event, kEventClassAppleEvent, kEventAppleEvent),
(self._on_command, kEventClassCommand, kEventProcessCommand),
]
ae_handlers = [
(self._on_ae_quit, kCoreEventClass, kAEQuitApplication),
]
# Install the application-wide handlers
for method, cls, event in handlers:
proc = EventHandlerProcPtr(method)
self._carbon_event_handlers.append(proc)
upp = carbon.NewEventHandlerUPP(proc)
types = EventTypeSpec()
types.eventClass = cls
types.eventKind = event
handler_ref = EventHandlerRef()
carbon.InstallEventHandler(
target,
upp,
1,
byref(types),
c_void_p(),
byref(handler_ref))
self._carbon_event_handler_refs.append(handler_ref)
# Install Apple event handlers
for method, cls, event in ae_handlers:
proc = EventHandlerProcPtr(method)
self._carbon_event_handlers.append(proc)
upp = carbon.NewAEEventHandlerUPP(proc)
carbon.AEInstallEventHandler(
cls,
event,
upp,
0,
False)
def _on_command(self, next_handler, ev, data):
command = HICommand()
carbon.GetEventParameter(ev, kEventParamDirectObject,
typeHICommand, c_void_p(), sizeof(command), c_void_p(),
byref(command))
if command.commandID == kHICommandQuit:
self._on_quit()
return noErr
def _on_mouse_down(self, next_handler, ev, data):
# Check for menubar hit
position = Point()
carbon.GetEventParameter(ev, kEventParamMouseLocation,
typeQDPoint, c_void_p(), sizeof(position), c_void_p(),
byref(position))
if carbon.FindWindow(position, None) == inMenuBar:
# Mouse down in menu bar. MenuSelect() takes care of all
# menu tracking and blocks until the menu is dismissed.
# Use command events to handle actual menu item invokations.
# This function blocks, so tell the event loop it needs to install
# a timer.
app.event_loop.enter_blocking()
carbon.MenuSelect(position)
app.event_loop.exit_blocking()
# Menu selection has now returned. Remove highlight from the
# menubar.
carbon.HiliteMenu(0)
carbon.CallNextEventHandler(next_handler, ev)
return noErr
def _on_apple_event(self, next_handler, ev, data):
# Somewhat involved way of redispatching Apple event contained
# within a Carbon event, described in
# http://developer.apple.com/documentation/AppleScript/
# Conceptual/AppleEvents/dispatch_aes_aepg/chapter_4_section_3.html
release = False
if carbon.IsEventInQueue(carbon.GetMainEventQueue(), ev):
carbon.RetainEvent(ev)
release = True
carbon.RemoveEventFromQueue(carbon.GetMainEventQueue(), ev)
ev_record = EventRecord()
carbon.ConvertEventRefToEventRecord(ev, byref(ev_record))
carbon.AEProcessAppleEvent(byref(ev_record))
if release:
carbon.ReleaseEvent(ev)
return noErr
def _on_ae_quit(self, ae, reply, refcon):
self._on_quit()
return noErr
def _on_quit(self):
'''Called when the user tries to quit the application.
This is not an actual event handler, it is called in response
to Command+Q, the Quit menu item, and the Dock context menu's Quit
item.
The default implementation calls `EventLoop.exit` on
`pyglet.app.event_loop`.
'''
app.event_loop.exit()
class CarbonScreen(Screen):
_initial_mode = None
def __init__(self, display, id):
self.display = display
rect = carbon.CGDisplayBounds(id)
super(CarbonScreen, self).__init__(display,
int(rect.origin.x), int(rect.origin.y),
int(rect.size.width), int(rect.size.height))
self.id = id
mode = carbon.CGDisplayCurrentMode(id)
kCGDisplayRefreshRate = create_cfstring('RefreshRate')
number = carbon.CFDictionaryGetValue(mode, kCGDisplayRefreshRate)
refresh = c_long()
kCFNumberLongType = 10
carbon.CFNumberGetValue(number, kCFNumberLongType, byref(refresh))
self._refresh_rate = refresh.value
def get_gdevice(self):
gdevice = POINTER(None)()
_oscheck(carbon.DMGetGDeviceByDisplayID(self.id, byref(gdevice), False))
return gdevice
def get_matching_configs(self, template):
canvas = CarbonCanvas(self.display, self, None)
configs = template.match(canvas)
# XXX deprecate
for config in configs:
config.screen = self
return configs
def get_modes(self):
modes_array = carbon.CGDisplayAvailableModes(self.id)
n_modes_array = carbon.CFArrayGetCount(modes_array)
modes = []
for i in range(n_modes_array):
mode = carbon.CFArrayGetValueAtIndex(modes_array, i)
modes.append(CarbonScreenMode(self, mode))
return modes
def get_mode(self):
mode = carbon.CGDisplayCurrentMode(self.id)
return CarbonScreenMode(self, mode)
def set_mode(self, mode):
assert mode.screen is self
if not self._initial_mode:
self._initial_mode = self.get_mode()
_oscheck(carbon.CGDisplayCapture(self.id))
_oscheck(carbon.CGDisplaySwitchToMode(self.id, mode.mode))
self.width = mode.width
self.height = mode.height
def restore_mode(self):
if self._initial_mode:
_oscheck(carbon.CGDisplaySwitchToMode(self.id,
self._initial_mode.mode))
_oscheck(carbon.CGDisplayRelease(self.id))
class CarbonScreenMode(ScreenMode):
def __init__(self, screen, mode):
super(CarbonScreenMode, self).__init__(screen)
self.mode = mode
self.width = self._get_long('Width')
self.height = self._get_long('Height')
self.depth = self._get_long('BitsPerPixel')
self.rate = self._get_long('RefreshRate')
def _get_long(self, key):
kCFNumberLongType = 10
cfkey = create_cfstring(key)
number = carbon.CFDictionaryGetValue(self.mode, cfkey)
if not number:
return None
value = c_long()
carbon.CFNumberGetValue(number, kCFNumberLongType, byref(value))
return value.value
class CarbonCanvas(Canvas):
bounds = None
def __init__(self, display, screen, drawable):
super(CarbonCanvas, self).__init__(display)
self.screen = screen
self.drawable = drawable
class CarbonFullScreenCanvas(Canvas):
# XXX not used any more.
def __init__(self, display, screen, width, height):
super(CarbonFullScreenCanvas, self).__init__(display)
self.screen = screen
self.width = width
self.height = height
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Display and screen management.
Rendering is performed on a :class:`Canvas`, which conceptually could be an
off-screen buffer, the content area of a :class:`pyglet.window.Window`, or an
entire screen. Currently, canvases can only be created with windows (though
windows can be set fullscreen).
Windows and canvases must belong to a :class:`Display`. On Windows and Mac OS
X there is only one display, which can be obtained with :func:`get_display`.
Linux supports multiple displays, corresponding to discrete X11 display
connections and screens. :func:`get_display` on Linux returns the default
display and screen 0 (``localhost:0.0``); if a particular screen or display is
required then :class:`Display` can be instantiated directly.
Within a display one or more screens are attached. A :class:`Screen` often
corresponds to a physical attached monitor, however a monitor or projector set
up to clone another screen will not be listed. Use :meth:`Display.get_screens`
to get a list of the attached screens; these can then be queried for their
sizes and virtual positions on the desktop.
The size of a screen is determined by its current mode, which can be changed
by the application; see the documentation for :class:`Screen`.
:since: pyglet 1.2
'''
import sys
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
def get_display():
'''Get the default display device.
If there is already a :class:`Display` connection, that display will be
returned. Otherwise, a default :class:`Display` is created and returned.
If multiple display connections are active, an arbitrary one is returned.
:since: pyglet 1.2
:rtype: :class:`Display`
'''
# If there's an existing display, return it (return arbitrary display if
# there are multiple).
from pyglet.app import displays
for display in displays:
return display
# Otherwise, create a new display and return it.
return Display()
if _is_epydoc:
from pyglet.canvas.base import Display, Screen, Canvas, ScreenMode
else:
from pyglet import compat_platform
if compat_platform == 'darwin':
from pyglet import options as pyglet_options
if pyglet_options['darwin_cocoa']:
from pyglet.canvas.cocoa import CocoaDisplay as Display
from pyglet.canvas.cocoa import CocoaScreen as Screen
from pyglet.canvas.cocoa import CocoaCanvas as Canvas
else:
from pyglet.canvas.carbon import CarbonDisplay as Display
from pyglet.canvas.carbon import CarbonScreen as Screen
from pyglet.canvas.carbon import CarbonCanvas as Canvas
elif compat_platform in ('win32', 'cygwin'):
from pyglet.canvas.win32 import Win32Display as Display
from pyglet.canvas.win32 import Win32Screen as Screen
from pyglet.canvas.win32 import Win32Canvas as Canvas
else:
from pyglet.canvas.xlib import XlibDisplay as Display
from pyglet.canvas.xlib import XlibScreen as Screen
from pyglet.canvas.xlib import XlibCanvas as Canvas
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Group multiple small images into larger textures.
This module is used by `pyglet.resource` to efficiently pack small images into
larger textures. `TextureAtlas` maintains one texture; `TextureBin` manages a
collection of atlases of a given size.
Example usage::
# Load images from disk
car_image = pyglet.image.load('car.png')
boat_image = pyglet.image.load('boat.png')
# Pack these images into one or more textures
bin = TextureBin()
car_texture = bin.add(car_image)
boat_texture = bin.add(boat_image)
The result of `TextureBin.add` is a `TextureRegion` containing the image.
Once added, an image cannot be removed from a bin (or an atlas); nor can a
list of images be obtained from a given bin or atlas -- it is the
application's responsibility to keep track of the regions returned by the
``add`` methods.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import pyglet
class AllocatorException(Exception):
'''The allocator does not have sufficient free space for the requested
image size.'''
pass
class _Strip(object):
def __init__(self, y, max_height):
self.x = 0
self.y = y
self.max_height = max_height
self.y2 = y
def add(self, width, height):
assert width > 0 and height > 0
assert height <= self.max_height
x, y = self.x, self.y
self.x += width
self.y2 = max(self.y + height, self.y2)
return x, y
def compact(self):
self.max_height = self.y2 - self.y
class Allocator(object):
'''Rectangular area allocation algorithm.
Initialise with a given ``width`` and ``height``, then repeatedly
call `alloc` to retrieve free regions of the area and protect that
area from future allocations.
`Allocator` uses a fairly simple strips-based algorithm. It performs best
when rectangles are allocated in decreasing height order.
'''
def __init__(self, width, height):
'''Create an `Allocator` of the given size.
:Parameters:
`width` : int
Width of the allocation region.
`height` : int
Height of the allocation region.
'''
assert width > 0 and height > 0
self.width = width
self.height = height
self.strips = [_Strip(0, height)]
self.used_area = 0
def alloc(self, width, height):
'''Get a free area in the allocator of the given size.
After calling `alloc`, the requested area will no longer be used.
If there is not enough room to fit the given area `AllocatorException`
is raised.
:Parameters:
`width` : int
Width of the area to allocate.
`height` : int
Height of the area to allocate.
:rtype: int, int
:return: The X and Y coordinates of the bottom-left corner of the
allocated region.
'''
for strip in self.strips:
if self.width - strip.x >= width and strip.max_height >= height:
self.used_area += width * height
return strip.add(width, height)
if self.width >= width and self.height - strip.y2 >= height:
self.used_area += width * height
strip.compact()
newstrip = _Strip(strip.y2, self.height - strip.y2)
self.strips.append(newstrip)
return newstrip.add(width, height)
raise AllocatorException('No more space in %r for box %dx%d' % (
self, width, height))
def get_usage(self):
'''Get the fraction of area already allocated.
This method is useful for debugging and profiling only.
:rtype: float
'''
return self.used_area / float(self.width * self.height)
def get_fragmentation(self):
'''Get the fraction of area that's unlikely to ever be used, based on
current allocation behaviour.
This method is useful for debugging and profiling only.
:rtype: float
'''
# The total unused area in each compacted strip is summed.
if not self.strips:
return 0.
possible_area = self.strips[-1].y2 * self.width
return 1.0 - self.used_area / float(possible_area)
class TextureAtlas(object):
'''Collection of images within a texture.
'''
def __init__(self, width=256, height=256):
'''Create a texture atlas of the given size.
:Parameters:
`width` : int
Width of the underlying texture.
`height` : int
Height of the underlying texture.
'''
self.texture = pyglet.image.Texture.create(
width, height, pyglet.gl.GL_RGBA, rectangle=True)
self.allocator = Allocator(width, height)
def add(self, img):
'''Add an image to the atlas.
This method will fail if the given image cannot be transferred
directly to a texture (for example, if it is another texture).
`ImageData` is the usual image type for this method.
`AllocatorException` will be raised if there is no room in the atlas
for the image.
:Parameters:
`img` : `AbstractImage`
The image to add.
:rtype: `TextureRegion`
:return: The region of the atlas containing the newly added image.
'''
x, y = self.allocator.alloc(img.width, img.height)
self.texture.blit_into(img, x, y, 0)
region = self.texture.get_region(x, y, img.width, img.height)
return region
class TextureBin(object):
'''Collection of texture atlases.
`TextureBin` maintains a collection of texture atlases, and creates new
ones as necessary to accommodate images added to the bin.
'''
def __init__(self, texture_width=256, texture_height=256):
'''Create a texture bin for holding atlases of the given size.
:Parameters:
`texture_width` : int
Width of texture atlases to create.
`texture_height` : int
Height of texture atlases to create.
'''
self.atlases = []
self.texture_width = texture_width
self.texture_height = texture_height
def add(self, img):
'''Add an image into this texture bin.
This method calls `TextureAtlas.add` for the first atlas that has room
for the image.
`AllocatorException` is raised if the image exceeds the dimensions of
``texture_width`` and ``texture_height``.
:Parameters:
`img` : `AbstractImage`
The image to add.
:rtype: `TextureRegion`
:return: The region of an atlas containing the newly added image.
'''
for atlas in list(self.atlases):
try:
return atlas.add(img)
except AllocatorException:
# Remove atlases that are no longer useful (this is so their
# textures can later be freed if the images inside them get
# collected).
if img.width < 64 and img.height < 64:
self.atlases.remove(atlas)
atlas = TextureAtlas(self.texture_width, self.texture_height)
self.atlases.append(atlas)
return atlas.add(img)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from pyglet.image import ImageData, Animation, AnimationFrame
from pyglet.image.codecs import *
from pyglet.libs.darwin.cocoapy import *
class QuartzImageDecoder(ImageDecoder):
def get_file_extensions(self):
# Quartz can actually decode many more formats, but these are the most common.
return [ '.bmp', '.cur', '.gif', '.ico', '.jp2', '.jpg', '.jpeg',
'.pcx', '.png', '.tga', '.tif', '.tiff', '.xbm', '.xpm' ]
def get_animation_file_extensions(self):
return ['.gif']
def _get_pyglet_ImageData_from_source_at_index(self, sourceRef, index):
imageRef = c_void_p(quartz.CGImageSourceCreateImageAtIndex(sourceRef, index, None))
# Regardless of the internal format of the image (L, LA, RGB, RGBA, etc)
# we just automatically convert everything to an RGBA format.
format = 'RGBA'
rgbColorSpace = c_void_p(quartz.CGColorSpaceCreateDeviceRGB())
bitsPerComponent = 8
width = quartz.CGImageGetWidth(imageRef)
height = quartz.CGImageGetHeight(imageRef)
bytesPerRow = 4 * width
# Create a buffer to store the RGBA formatted data.
bufferSize = height * bytesPerRow
buffer = (c_ubyte * bufferSize)()
# Create a bitmap context for the RGBA formatted data.
# Note that premultiplied alpha is required:
# http://developer.apple.com/library/mac/#qa/qa1037/_index.html
bitmap = c_void_p(quartz.CGBitmapContextCreate(buffer,
width, height,
bitsPerComponent,
bytesPerRow,
rgbColorSpace,
kCGImageAlphaPremultipliedLast))
# Write the image data into the bitmap.
quartz.CGContextDrawImage(bitmap, NSMakeRect(0,0,width,height), imageRef)
quartz.CGImageRelease(imageRef)
quartz.CGContextRelease(bitmap)
quartz.CGColorSpaceRelease(rgbColorSpace)
pitch = bytesPerRow
return ImageData(width, height, format, buffer, -pitch)
def decode(self, file, filename):
file_bytes = file.read()
data = c_void_p(cf.CFDataCreate(None, file_bytes, len(file_bytes)))
# Second argument is an options dictionary. It might be a good idea to provide
# a value for kCGImageSourceTypeIdentifierHint here using filename extension.
sourceRef = c_void_p(quartz.CGImageSourceCreateWithData(data, None))
image = self._get_pyglet_ImageData_from_source_at_index(sourceRef, 0)
cf.CFRelease(data)
cf.CFRelease(sourceRef)
return image
def decode_animation(self, file, filename):
# If file is not an animated GIF, it will be loaded as a single-frame animation.
file_bytes = file.read()
data = c_void_p(cf.CFDataCreate(None, file_bytes, len(file_bytes)))
sourceRef = c_void_p(quartz.CGImageSourceCreateWithData(data, None))
# Get number of frames in the animation.
count = quartz.CGImageSourceGetCount(sourceRef)
frames = []
for index in range(count):
# Try to determine frame duration from GIF properties dictionary.
duration = 0.1 # default duration if none found
props = c_void_p(quartz.CGImageSourceCopyPropertiesAtIndex(sourceRef, index, None))
if cf.CFDictionaryContainsKey(props, kCGImagePropertyGIFDictionary):
gif_props = c_void_p(cf.CFDictionaryGetValue(props, kCGImagePropertyGIFDictionary))
if cf.CFDictionaryContainsKey(gif_props, kCGImagePropertyGIFDelayTime):
duration = cfnumber_to_number(c_void_p(cf.CFDictionaryGetValue(gif_props, kCGImagePropertyGIFDelayTime)))
cf.CFRelease(props)
image = self._get_pyglet_ImageData_from_source_at_index(sourceRef, index)
frames.append( AnimationFrame(image, duration) )
cf.CFRelease(data)
cf.CFRelease(sourceRef)
return Animation(frames)
def get_decoders():
return [ QuartzImageDecoder() ]
def get_encoders():
return []
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: pil.py 163 2006-11-13 04:15:46Z Alex.Holkner $'
from ctypes import *
from pyglet.com import IUnknown
from pyglet.gl import *
from pyglet.image import *
from pyglet.image.codecs import *
from pyglet.libs.win32.constants import *
from pyglet.libs.win32.types import *
from pyglet.libs.win32 import _kernel32 as kernel32
ole32 = windll.ole32
gdiplus = windll.gdiplus
LPSTREAM = c_void_p
REAL = c_float
PixelFormat1bppIndexed = 196865
PixelFormat4bppIndexed = 197634
PixelFormat8bppIndexed = 198659
PixelFormat16bppGrayScale = 1052676
PixelFormat16bppRGB555 = 135173
PixelFormat16bppRGB565 = 135174
PixelFormat16bppARGB1555 = 397319
PixelFormat24bppRGB = 137224
PixelFormat32bppRGB = 139273
PixelFormat32bppARGB = 2498570
PixelFormat32bppPARGB = 925707
PixelFormat48bppRGB = 1060876
PixelFormat64bppARGB = 3424269
PixelFormat64bppPARGB = 29622286
PixelFormatMax = 15
ImageLockModeRead = 1
ImageLockModeWrite = 2
ImageLockModeUserInputBuf = 4
class GdiplusStartupInput(Structure):
_fields_ = [
('GdiplusVersion', c_uint32),
('DebugEventCallback', c_void_p),
('SuppressBackgroundThread', BOOL),
('SuppressExternalCodecs', BOOL)
]
class GdiplusStartupOutput(Structure):
_fields = [
('NotificationHookProc', c_void_p),
('NotificationUnhookProc', c_void_p)
]
class BitmapData(Structure):
_fields_ = [
('Width', c_uint),
('Height', c_uint),
('Stride', c_int),
('PixelFormat', c_int),
('Scan0', POINTER(c_byte)),
('Reserved', POINTER(c_uint))
]
class Rect(Structure):
_fields_ = [
('X', c_int),
('Y', c_int),
('Width', c_int),
('Height', c_int)
]
PropertyTagFrameDelay = 0x5100
class PropertyItem(Structure):
_fields_ = [
('id', c_uint),
('length', c_ulong),
('type', c_short),
('value', c_void_p)
]
INT_PTR = POINTER(INT)
UINT_PTR = POINTER(UINT)
ole32.CreateStreamOnHGlobal.argtypes = [HGLOBAL, BOOL, LPSTREAM]
gdiplus.GdipBitmapLockBits.restype = c_int
gdiplus.GdipBitmapLockBits.argtypes = [c_void_p, c_void_p, UINT, c_int, c_void_p]
gdiplus.GdipBitmapUnlockBits.restype = c_int
gdiplus.GdipBitmapUnlockBits.argtypes = [c_void_p, c_void_p]
gdiplus.GdipCloneStringFormat.restype = c_int
gdiplus.GdipCloneStringFormat.argtypes = [c_void_p, c_void_p]
gdiplus.GdipCreateBitmapFromScan0.restype = c_int
gdiplus.GdipCreateBitmapFromScan0.argtypes = [c_int, c_int, c_int, c_int, POINTER(BYTE), c_void_p]
gdiplus.GdipCreateBitmapFromStream.restype = c_int
gdiplus.GdipCreateBitmapFromStream.argtypes = [c_void_p, c_void_p]
gdiplus.GdipCreateFont.restype = c_int
gdiplus.GdipCreateFont.argtypes = [c_void_p, REAL, INT, c_int, c_void_p]
gdiplus.GdipCreateFontFamilyFromName.restype = c_int
gdiplus.GdipCreateFontFamilyFromName.argtypes = [c_wchar_p, c_void_p, c_void_p]
gdiplus.GdipCreateMatrix.restype = None
gdiplus.GdipCreateMatrix.argtypes = [c_void_p]
gdiplus.GdipCreateSolidFill.restype = c_int
gdiplus.GdipCreateSolidFill.argtypes = [c_int, c_void_p] # ARGB
gdiplus.GdipDisposeImage.restype = c_int
gdiplus.GdipDisposeImage.argtypes = [c_void_p]
gdiplus.GdipDrawString.restype = c_int
gdiplus.GdipDrawString.argtypes = [c_void_p, c_wchar_p, c_int, c_void_p, c_void_p, c_void_p, c_void_p]
gdiplus.GdipFlush.restype = c_int
gdiplus.GdipFlush.argtypes = [c_void_p, c_int]
gdiplus.GdipGetImageDimension.restype = c_int
gdiplus.GdipGetImageDimension.argtypes = [c_void_p, POINTER(REAL), POINTER(REAL)]
gdiplus.GdipGetImageGraphicsContext.restype = c_int
gdiplus.GdipGetImageGraphicsContext.argtypes = [c_void_p, c_void_p]
gdiplus.GdipGetImagePixelFormat.restype = c_int
gdiplus.GdipGetImagePixelFormat.argtypes = [c_void_p, c_void_p]
gdiplus.GdipGetPropertyItem.restype = c_int
gdiplus.GdipGetPropertyItem.argtypes = [c_void_p, c_uint, c_uint, c_void_p]
gdiplus.GdipGetPropertyItemSize.restype = c_int
gdiplus.GdipGetPropertyItemSize.argtypes = [c_void_p, c_uint, UINT_PTR]
gdiplus.GdipGraphicsClear.restype = c_int
gdiplus.GdipGraphicsClear.argtypes = [c_void_p, c_int] # ARGB
gdiplus.GdipImageGetFrameCount.restype = c_int
gdiplus.GdipImageGetFrameCount.argtypes = [c_void_p, c_void_p, UINT_PTR]
gdiplus.GdipImageGetFrameDimensionsCount.restype = c_int
gdiplus.GdipImageGetFrameDimensionsCount.argtypes = [c_void_p, UINT_PTR]
gdiplus.GdipImageGetFrameDimensionsList.restype = c_int
gdiplus.GdipImageGetFrameDimensionsList.argtypes = [c_void_p, c_void_p, UINT]
gdiplus.GdipImageSelectActiveFrame.restype = c_int
gdiplus.GdipImageSelectActiveFrame.argtypes = [c_void_p, c_void_p, UINT]
gdiplus.GdipMeasureString.restype = c_int
gdiplus.GdipMeasureString.argtypes = [c_void_p, c_wchar_p, c_int, c_void_p, c_void_p, c_void_p, c_void_p, INT_PTR, INT_PTR]
gdiplus.GdipNewPrivateFontCollection.restype = c_int
gdiplus.GdipNewPrivateFontCollection.argtypes = [c_void_p]
gdiplus.GdipPrivateAddMemoryFont.restype = c_int
gdiplus.GdipPrivateAddMemoryFont.argtypes = [c_void_p, c_void_p, c_int]
gdiplus.GdipSetPageUnit.restype = c_int
gdiplus.GdipSetPageUnit.argtypes = [c_void_p, c_int]
gdiplus.GdipSetStringFormatFlags.restype = c_int
gdiplus.GdipSetStringFormatFlags.argtypes = [c_void_p, c_int]
gdiplus.GdipSetTextRenderingHint.restype = c_int
gdiplus.GdipSetTextRenderingHint.argtypes = [c_void_p, c_int]
gdiplus.GdipStringFormatGetGenericTypographic.restype = c_int
gdiplus.GdipStringFormatGetGenericTypographic.argtypes = [c_void_p]
gdiplus.GdiplusShutdown.restype = None
gdiplus.GdiplusShutdown.argtypes = [POINTER(ULONG)]
gdiplus.GdiplusStartup.restype = c_int
gdiplus.GdiplusStartup.argtypes = [c_void_p, c_void_p, c_void_p]
class GDIPlusDecoder(ImageDecoder):
def get_file_extensions(self):
return ['.bmp', '.gif', '.jpg', '.jpeg', '.exif', '.png', '.tif',
'.tiff']
def get_animation_file_extensions(self):
# TIFF also supported as a multi-page image; but that's not really an
# animation, is it?
return ['.gif']
def _load_bitmap(self, file, filename):
data = file.read()
# Create a HGLOBAL with image data
hglob = kernel32.GlobalAlloc(GMEM_MOVEABLE, len(data))
ptr = kernel32.GlobalLock(hglob)
memmove(ptr, data, len(data))
kernel32.GlobalUnlock(hglob)
# Create IStream for the HGLOBAL
self.stream = IUnknown()
ole32.CreateStreamOnHGlobal(hglob, True, byref(self.stream))
# Load image from stream
bitmap = c_void_p()
status = gdiplus.GdipCreateBitmapFromStream(self.stream, byref(bitmap))
if status != 0:
self.stream.Release()
raise ImageDecodeException(
'GDI+ cannot load %r' % (filename or file))
return bitmap
def _get_image(self, bitmap):
# Get size of image (Bitmap subclasses Image)
width = REAL()
height = REAL()
gdiplus.GdipGetImageDimension(bitmap, byref(width), byref(height))
width = int(width.value)
height = int(height.value)
# Get image pixel format
pf = c_int()
gdiplus.GdipGetImagePixelFormat(bitmap, byref(pf))
pf = pf.value
# Reverse from what's documented because of Intel little-endianness.
format = 'BGRA'
if pf == PixelFormat24bppRGB:
format = 'BGR'
elif pf == PixelFormat32bppRGB:
pass
elif pf == PixelFormat32bppARGB:
pass
elif pf in (PixelFormat16bppARGB1555, PixelFormat32bppPARGB,
PixelFormat64bppARGB, PixelFormat64bppPARGB):
pf = PixelFormat32bppARGB
else:
format = 'BGR'
pf = PixelFormat24bppRGB
# Lock pixel data in best format
rect = Rect()
rect.X = 0
rect.Y = 0
rect.Width = width
rect.Height = height
bitmap_data = BitmapData()
gdiplus.GdipBitmapLockBits(bitmap,
byref(rect), ImageLockModeRead, pf, byref(bitmap_data))
# Create buffer for RawImage
buffer = create_string_buffer(bitmap_data.Stride * height)
memmove(buffer, bitmap_data.Scan0, len(buffer))
# Unlock data
gdiplus.GdipBitmapUnlockBits(bitmap, byref(bitmap_data))
return ImageData(width, height, format, buffer, -bitmap_data.Stride)
def _delete_bitmap(self, bitmap):
# Release image and stream
gdiplus.GdipDisposeImage(bitmap)
self.stream.Release()
def decode(self, file, filename):
bitmap = self._load_bitmap(file, filename)
image = self._get_image(bitmap)
self._delete_bitmap(bitmap)
return image
def decode_animation(self, file, filename):
bitmap = self._load_bitmap(file, filename)
dimension_count = c_uint()
gdiplus.GdipImageGetFrameDimensionsCount(bitmap, byref(dimension_count))
if dimension_count.value < 1:
self._delete_bitmap(bitmap)
raise ImageDecodeException('Image has no frame dimensions')
# XXX Make sure this dimension is time?
dimensions = (c_void_p * dimension_count.value)()
gdiplus.GdipImageGetFrameDimensionsList(bitmap, dimensions,
dimension_count.value)
frame_count = c_uint()
gdiplus.GdipImageGetFrameCount(bitmap, dimensions, byref(frame_count))
prop_id = PropertyTagFrameDelay
prop_size = c_uint()
gdiplus.GdipGetPropertyItemSize(bitmap, prop_id, byref(prop_size))
prop_buffer = c_buffer(prop_size.value)
prop_item = cast(prop_buffer, POINTER(PropertyItem)).contents
gdiplus.GdipGetPropertyItem(bitmap, prop_id, prop_size.value,
prop_buffer)
n_delays = prop_item.length // sizeof(c_long)
delays = cast(prop_item.value, POINTER(c_long * n_delays)).contents
frames = []
for i in range(frame_count.value):
gdiplus.GdipImageSelectActiveFrame(bitmap, dimensions, i)
image = self._get_image(bitmap)
delay = delays[i]
if delay <= 1:
delay = 10
frames.append(AnimationFrame(image, delay/100.))
self._delete_bitmap(bitmap)
return Animation(frames)
def get_decoders():
return [GDIPlusDecoder()]
def get_encoders():
return []
def init():
token = c_ulong()
startup_in = GdiplusStartupInput()
startup_in.GdiplusVersion = 1
startup_out = GdiplusStartupOutput()
gdiplus.GdiplusStartup(byref(token), byref(startup_in), byref(startup_out))
# Shutdown later?
# gdiplus.GdiplusShutdown(token)
init()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: pil.py 163 2006-11-13 04:15:46Z Alex.Holkner $'
import sys
from ctypes import *
from pyglet.gl import *
from pyglet.image import *
from pyglet.image.codecs import *
from pyglet.window.carbon import carbon, quicktime, _oscheck
from pyglet.libs.darwin.constants import _name
from pyglet.libs.darwin.types import *
Handle = POINTER(POINTER(c_byte))
GWorldPtr = c_void_p
carbon.NewHandle.restype = Handle
HandleDataHandlerSubType = _name('hndl')
PointerDataHandlerSubType = _name('ptr ')
kDataHCanRead = 1
kDataRefExtensionFileName = _name('fnam')
kDataRefExtensionMIMEType = _name('mime')
ComponentInstance = c_void_p
k1MonochromePixelFormat = 0x00000001
k2IndexedPixelFormat = 0x00000002
k4IndexedPixelFormat = 0x00000004
k8IndexedPixelFormat = 0x00000008
k16BE555PixelFormat = 0x00000010
k24RGBPixelFormat = 0x00000018
k32ARGBPixelFormat = 0x00000020
k32BGRAPixelFormat = _name('BGRA')
k1IndexedGrayPixelFormat = 0x00000021
k2IndexedGrayPixelFormat = 0x00000022
k4IndexedGrayPixelFormat = 0x00000024
k8IndexedGrayPixelFormat = 0x00000028
kNativeEndianPixMap = 1 << 8
kGraphicsImporterDontDoGammaCorrection = 1 << 0
kGraphicsImporterDontUseColorMatching = 1 << 3
newMovieActive = 1
noErr = 0
movieTrackMediaType = 1 << 0
movieTrackCharacteristic = 1 << 1
movieTrackEnabledOnly = 1 << 2
VisualMediaCharacteristic = _name('eyes')
nextTimeMediaSample = 1
class PointerDataRefRecord(Structure):
_fields_ = [
('data', c_void_p),
('dataLength', c_long)
]
def Str255(value):
return create_string_buffer(chr(len(value)) + value)
class QuickTimeImageDecoder(ImageDecoder):
def get_file_extensions(self):
# Only most common ones shown here
return ['.bmp', '.cur', '.gif', '.ico', '.jpg', '.jpeg', '.pcx', '.png',
'.tga', '.tif', '.tiff', '.xbm', '.xpm']
def get_animation_file_extensions(self):
return ['.gif']
def _get_data_ref(self, file, filename):
self._data_hold = data = create_string_buffer(file.read())
dataref = carbon.NewHandle(sizeof(PointerDataRefRecord))
datarec = cast(dataref,
POINTER(POINTER(PointerDataRefRecord))).contents.contents
datarec.data = addressof(data)
datarec.dataLength = len(data)
self._data_handler_holder = data_handler = ComponentInstance()
r = quicktime.OpenADataHandler(dataref, PointerDataHandlerSubType,
None, 0, None, kDataHCanRead, byref(data_handler))
_oscheck(r)
extension_handle = Handle()
self._filename_hold = filename = Str255(filename)
r = carbon.PtrToHand(filename, byref(extension_handle), len(filename))
r = quicktime.DataHSetDataRefExtension(data_handler, extension_handle,
kDataRefExtensionFileName)
_oscheck(r)
quicktime.DisposeHandle(extension_handle)
quicktime.DisposeHandle(dataref)
dataref = c_void_p()
r = quicktime.DataHGetDataRef(data_handler, byref(dataref))
_oscheck(r)
quicktime.CloseComponent(data_handler)
return dataref
def _get_formats(self):
# TODO choose 24 bit where appropriate.
if sys.byteorder == 'big':
format = 'ARGB'
qtformat = k32ARGBPixelFormat
else:
format = 'BGRA'
qtformat = k32BGRAPixelFormat
return format, qtformat
def decode(self, file, filename):
dataref = self._get_data_ref(file, filename)
importer = ComponentInstance()
quicktime.GetGraphicsImporterForDataRef(dataref,
PointerDataHandlerSubType, byref(importer))
if not importer:
raise ImageDecodeException(filename or file)
rect = Rect()
quicktime.GraphicsImportGetNaturalBounds(importer, byref(rect))
width = rect.right
height = rect.bottom
format, qtformat = self._get_formats()
buffer = (c_byte * (width * height * len(format)))()
world = GWorldPtr()
quicktime.QTNewGWorldFromPtr(byref(world), qtformat,
byref(rect), c_void_p(), c_void_p(), 0, buffer,
len(format) * width)
flags = (kGraphicsImporterDontUseColorMatching |
kGraphicsImporterDontDoGammaCorrection)
quicktime.GraphicsImportSetFlags(importer, flags)
quicktime.GraphicsImportSetGWorld(importer, world, c_void_p())
result = quicktime.GraphicsImportDraw(importer)
quicktime.DisposeGWorld(world)
quicktime.CloseComponent(importer)
if result != 0:
raise ImageDecodeException(filename or file)
pitch = len(format) * width
return ImageData(width, height, format, buffer, -pitch)
def decode_animation(self, file, filename):
# TODO: Stop playing chicken with the GC
# TODO: Cleanup in errors
quicktime.EnterMovies()
data_ref = self._get_data_ref(file, filename)
if not data_ref:
raise ImageDecodeException(filename or file)
movie = c_void_p()
id = c_short()
result = quicktime.NewMovieFromDataRef(byref(movie),
newMovieActive,
0,
data_ref,
PointerDataHandlerSubType)
if not movie:
#_oscheck(result)
raise ImageDecodeException(filename or file)
quicktime.GoToBeginningOfMovie(movie)
time_scale = float(quicktime.GetMovieTimeScale(movie))
format, qtformat = self._get_formats()
# Get movie width and height
rect = Rect()
quicktime.GetMovieBox(movie, byref(rect))
width = rect.right
height = rect.bottom
pitch = len(format) * width
# Set gworld
buffer = (c_byte * (width * height * len(format)))()
world = GWorldPtr()
quicktime.QTNewGWorldFromPtr(byref(world), qtformat,
byref(rect), c_void_p(), c_void_p(), 0, buffer,
len(format) * width)
quicktime.SetGWorld(world, 0)
quicktime.SetMovieGWorld(movie, world, 0)
visual = quicktime.GetMovieIndTrackType(movie, 1,
VisualMediaCharacteristic,
movieTrackCharacteristic)
if not visual:
raise ImageDecodeException('No video track')
time = 0
interesting_time = c_int()
quicktime.GetTrackNextInterestingTime(
visual,
nextTimeMediaSample,
time,
1,
byref(interesting_time),
None)
duration = interesting_time.value / time_scale
frames = []
while time >= 0:
result = quicktime.GetMoviesError()
if result == noErr:
# force redraw
result = quicktime.UpdateMovie(movie)
if result == noErr:
# process movie
quicktime.MoviesTask(movie, 0)
result = quicktime.GetMoviesError()
_oscheck(result)
buffer_copy = (c_byte * len(buffer))()
memmove(buffer_copy, buffer, len(buffer))
image = ImageData(width, height, format, buffer_copy, -pitch)
frames.append(AnimationFrame(image, duration))
interesting_time = c_int()
duration = c_int()
quicktime.GetTrackNextInterestingTime(
visual,
nextTimeMediaSample,
time,
1,
byref(interesting_time),
byref(duration))
quicktime.SetMovieTimeValue(movie, interesting_time)
time = interesting_time.value
duration = duration.value / time_scale
if duration <= 0.01:
duration = 0.1
quicktime.DisposeMovie(movie)
carbon.DisposeHandle(data_ref)
quicktime.ExitMovies()
return Animation(frames)
def get_decoders():
return [QuickTimeImageDecoder()]
def get_encoders():
return []
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Encoder and decoder for PNG files, using PyPNG (pypng.py).
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import array
from pyglet.gl import *
from pyglet.image import *
from pyglet.image.codecs import *
import pyglet.image.codecs.pypng
class PNGImageDecoder(ImageDecoder):
def get_file_extensions(self):
return ['.png']
def decode(self, file, filename):
try:
reader = pyglet.image.codecs.pypng.Reader(file=file)
width, height, pixels, metadata = reader.read()
except Exception, e:
raise ImageDecodeException(
'PyPNG cannot read %r: %s' % (filename or file, e))
if metadata['greyscale']:
if metadata['has_alpha']:
format = 'LA'
else:
format = 'L'
else:
if metadata['has_alpha']:
format = 'RGBA'
else:
format = 'RGB'
pitch = len(format) * width
return ImageData(width, height, format, pixels.tostring(), -pitch)
class PNGImageEncoder(ImageEncoder):
def get_file_extensions(self):
return ['.png']
def encode(self, image, file, filename):
image = image.get_image_data()
has_alpha = 'A' in image.format
greyscale = len(image.format) < 3
if has_alpha:
if greyscale:
image.format = 'LA'
else:
image.format = 'RGBA'
else:
if greyscale:
image.format = 'L'
else:
image.format = 'RGB'
image.pitch = -(image.width * len(image.format))
writer = pyglet.image.codecs.pypng.Writer(
image.width, image.height,
bytes_per_sample=1,
greyscale=greyscale,
has_alpha=has_alpha)
data = array.array('B')
data.fromstring(image.data)
writer.write_array(file, data)
def get_decoders():
return [PNGImageDecoder()]
def get_encoders():
return [PNGImageEncoder()]
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''DDS texture loader.
Reference: http://msdn2.microsoft.com/en-us/library/bb172993.aspx
'''
from __future__ import division
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
import struct
from pyglet.gl import *
from pyglet.image import CompressedImageData
from pyglet.image import codecs
from pyglet.image.codecs import s3tc
from pyglet.compat import izip_longest as compat_izip_longest
class DDSException(codecs.ImageDecodeException):
exception_priority = 0
# dwFlags of DDSURFACEDESC2
DDSD_CAPS = 0x00000001
DDSD_HEIGHT = 0x00000002
DDSD_WIDTH = 0x00000004
DDSD_PITCH = 0x00000008
DDSD_PIXELFORMAT = 0x00001000
DDSD_MIPMAPCOUNT = 0x00020000
DDSD_LINEARSIZE = 0x00080000
DDSD_DEPTH = 0x00800000
# ddpfPixelFormat of DDSURFACEDESC2
DDPF_ALPHAPIXELS = 0x00000001
DDPF_FOURCC = 0x00000004
DDPF_RGB = 0x00000040
# dwCaps1 of DDSCAPS2
DDSCAPS_COMPLEX = 0x00000008
DDSCAPS_TEXTURE = 0x00001000
DDSCAPS_MIPMAP = 0x00400000
# dwCaps2 of DDSCAPS2
DDSCAPS2_CUBEMAP = 0x00000200
DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400
DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800
DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000
DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000
DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000
DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000
DDSCAPS2_VOLUME = 0x00200000
class _filestruct(object):
def __init__(self, data):
if len(data) < self.get_size():
raise DDSException('Not a DDS file')
items = struct.unpack(self.get_format(), data)
for field, value in compat_izip_longest(self._fields,
items,
fillvalue=None):
setattr(self, field[0], value)
def __repr__(self):
name = self.__class__.__name__
return '%s(%s)' % \
(name, (', \n%s' % (' ' * (len(name) + 1))).join( \
['%s = %s' % (field[0], repr(getattr(self, field[0]))) \
for field in self._fields]))
@classmethod
def get_format(cls):
return '<' + ''.join([f[1] for f in cls._fields])
@classmethod
def get_size(cls):
return struct.calcsize(cls.get_format())
class DDSURFACEDESC2(_filestruct):
_fields = [
('dwMagic', '4s'),
('dwSize', 'I'),
('dwFlags', 'I'),
('dwHeight', 'I'),
('dwWidth', 'I'),
('dwPitchOrLinearSize', 'I'),
('dwDepth', 'I'),
('dwMipMapCount', 'I'),
('dwReserved1', '44s'),
('ddpfPixelFormat', '32s'),
('dwCaps1', 'I'),
('dwCaps2', 'I'),
('dwCapsReserved', '8s'),
('dwReserved2', 'I')
]
def __init__(self, data):
super(DDSURFACEDESC2, self).__init__(data)
self.ddpfPixelFormat = DDPIXELFORMAT(self.ddpfPixelFormat)
class DDPIXELFORMAT(_filestruct):
_fields = [
('dwSize', 'I'),
('dwFlags', 'I'),
('dwFourCC', '4s'),
('dwRGBBitCount', 'I'),
('dwRBitMask', 'I'),
('dwGBitMask', 'I'),
('dwBBitMask', 'I'),
('dwRGBAlphaBitMask', 'I')
]
_compression_formats = {
(b'DXT1', False): (GL_COMPRESSED_RGB_S3TC_DXT1_EXT, s3tc.decode_dxt1_rgb),
(b'DXT1', True): (GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, s3tc.decode_dxt1_rgba),
(b'DXT3', False): (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, s3tc.decode_dxt3),
(b'DXT3', True): (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, s3tc.decode_dxt3),
(b'DXT5', False): (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, s3tc.decode_dxt5),
(b'DXT5', True): (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, s3tc.decode_dxt5),
}
def _check_error():
e = glGetError()
if e != 0:
print 'GL error %d' % e
class DDSImageDecoder(codecs.ImageDecoder):
def get_file_extensions(self):
return ['.dds']
def decode(self, file, filename):
header = file.read(DDSURFACEDESC2.get_size())
desc = DDSURFACEDESC2(header)
if desc.dwMagic != b'DDS ' or desc.dwSize != 124:
raise DDSException('Invalid DDS file (incorrect header).')
width = desc.dwWidth
height = desc.dwHeight
mipmaps = 1
if desc.dwFlags & DDSD_DEPTH:
raise DDSException('Volume DDS files unsupported')
if desc.dwFlags & DDSD_MIPMAPCOUNT:
mipmaps = desc.dwMipMapCount
if desc.ddpfPixelFormat.dwSize != 32:
raise DDSException('Invalid DDS file (incorrect pixel format).')
if desc.dwCaps2 & DDSCAPS2_CUBEMAP:
raise DDSException('Cubemap DDS files unsupported')
if not desc.ddpfPixelFormat.dwFlags & DDPF_FOURCC:
raise DDSException('Uncompressed DDS textures not supported.')
has_alpha = desc.ddpfPixelFormat.dwRGBAlphaBitMask != 0
selector = (desc.ddpfPixelFormat.dwFourCC, has_alpha)
if selector not in _compression_formats:
raise DDSException('Unsupported texture compression %s' % \
desc.ddpfPixelFormat.dwFourCC)
dformat, decoder = _compression_formats[selector]
if dformat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
block_size = 8
else:
block_size = 16
datas = []
w, h = width, height
for i in range(mipmaps):
if not w and not h:
break
if not w:
w = 1
if not h:
h = 1
size = ((w + 3) // 4) * ((h + 3) // 4) * block_size
data = file.read(size)
datas.append(data)
w >>= 1
h >>= 1
image = CompressedImageData(width, height, dformat, datas[0],
'GL_EXT_texture_compression_s3tc', decoder)
level = 0
for data in datas[1:]:
level += 1
image.set_mipmap_data(level, data)
return image
def get_decoders():
return [DDSImageDecoder()]
def get_encoders():
return []
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# $Id:$
'''Software decoder for S3TC compressed texture (i.e., DDS).
http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
'''
import ctypes
import re
from pyglet.gl import *
from pyglet.gl import gl_info
from pyglet.image import AbstractImage, Texture
split_8byte = re.compile('.' * 8, flags=re.DOTALL)
split_16byte = re.compile('.' * 16, flags=re.DOTALL)
class PackedImageData(AbstractImage):
_current_texture = None
def __init__(self, width, height, format, packed_format, data):
super(PackedImageData, self).__init__(width, height)
self.format = format
self.packed_format = packed_format
self.data = data
def unpack(self):
if self.packed_format == GL_UNSIGNED_SHORT_5_6_5:
# Unpack to GL_RGB. Assume self.data is already 16-bit
i = 0
out = (ctypes.c_ubyte * (self.width * self.height * 3))()
for c in self.data:
out[i+2] = (c & 0x1f) << 3
out[i+1] = (c & 0x7e0) >> 3
out[i] = (c & 0xf800) >> 8
i += 3
self.data = out
self.packed_format = GL_UNSIGNED_BYTE
def _get_texture(self):
if self._current_texture:
return self._current_texture
texture = Texture.create_for_size(
GL_TEXTURE_2D, self.width, self.height)
glBindTexture(texture.target, texture.id)
glTexParameteri(texture.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
if not gl_info.have_version(1, 2) or True:
self.unpack()
glTexImage2D(texture.target, texture.level,
self.format, self.width, self.height, 0,
self.format, self.packed_format, self.data)
self._current_texture = texture
return texture
texture = property(_get_texture)
def get_texture(self, rectangle=False, force_rectangle=False):
'''The parameters 'rectangle' and 'force_rectangle' are ignored.
See the documentation of the method 'AbstractImage.get_texture' for
a more detailed documentation of the method. '''
return self._get_texture()
def decode_dxt1_rgb(data, width, height):
# Decode to 16-bit RGB UNSIGNED_SHORT_5_6_5
out = (ctypes.c_uint16 * (width * height))()
# Read 8 bytes at a time
image_offset = 0
for c0_lo, c0_hi, c1_lo, c1_hi, b0, b1, b2, b3 in split_8byte.findall(data):
color0 = ord(c0_lo) | ord(c0_hi) << 8
color1 = ord(c1_lo) | ord(c1_hi) << 8
bits = ord(b0) | ord(b1) << 8 | ord(b2) << 16 | ord(b3) << 24
r0 = color0 & 0x1f
g0 = (color0 & 0x7e0) >> 5
b0 = (color0 & 0xf800) >> 11
r1 = color1 & 0x1f
g1 = (color1 & 0x7e0) >> 5
b1 = (color1 & 0xf800) >> 11
# i is the dest ptr for this block
i = image_offset
for y in range(4):
for x in range(4):
code = bits & 0x3
if code == 0:
out[i] = color0
elif code == 1:
out[i] = color1
elif code == 3 and color0 <= color1:
out[i] = 0
else:
if code == 2 and color0 > color1:
r = (2 * r0 + r1) / 3
g = (2 * g0 + g1) / 3
b = (2 * b0 + b1) / 3
elif code == 3 and color0 > color1:
r = (r0 + 2 * r1) / 3
g = (g0 + 2 * g1) / 3
b = (b0 + 2 * b1) / 3
else:
assert code == 2 and color0 <= color1
r = (r0 + r1) / 2
g = (g0 + g1) / 2
b = (b0 + b1) / 2
out[i] = r | g << 5 | b << 11
bits >>= 2
i += 1
i += width - 4
# Move dest ptr to next 4x4 block
advance_row = (image_offset + 4) % width == 0
image_offset += width * 3 * advance_row + 4
return PackedImageData(width, height,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, out)
def decode_dxt1_rgba(data, width, height):
# Decode to GL_RGBA
out = (ctypes.c_ubyte * (width * height * 4))()
pitch = width << 2
# Read 8 bytes at a time
image_offset = 0
for c0_lo, c0_hi, c1_lo, c1_hi, b0, b1, b2, b3 in split_8byte.findall(data):
color0 = ord(c0_lo) | ord(c0_hi) << 8
color1 = ord(c1_lo) | ord(c1_hi) << 8
bits = ord(b0) | ord(b1) << 8 | ord(b2) << 16 | ord(b3) << 24
r0 = color0 & 0x1f
g0 = (color0 & 0x7e0) >> 5
b0 = (color0 & 0xf800) >> 11
r1 = color1 & 0x1f
g1 = (color1 & 0x7e0) >> 5
b1 = (color1 & 0xf800) >> 11
# i is the dest ptr for this block
i = image_offset
for y in range(4):
for x in range(4):
code = bits & 0x3
a = 255
if code == 0:
r, g, b = r0, g0, b0
elif code == 1:
r, g, b = r1, g1, b1
elif code == 3 and color0 <= color1:
r = g = b = a = 0
else:
if code == 2 and color0 > color1:
r = (2 * r0 + r1) / 3
g = (2 * g0 + g1) / 3
b = (2 * b0 + b1) / 3
elif code == 3 and color0 > color1:
r = (r0 + 2 * r1) / 3
g = (g0 + 2 * g1) / 3
b = (b0 + 2 * b1) / 3
else:
assert code == 2 and color0 <= color1
r = (r0 + r1) / 2
g = (g0 + g1) / 2
b = (b0 + b1) / 2
out[i] = b << 3
out[i+1] = g << 2
out[i+2] = r << 3
out[i+3] = a << 4
bits >>= 2
i += 4
i += pitch - 16
# Move dest ptr to next 4x4 block
advance_row = (image_offset + 16) % pitch == 0
image_offset += pitch * 3 * advance_row + 16
return PackedImageData(width, height, GL_RGBA, GL_UNSIGNED_BYTE, out)
def decode_dxt3(data, width, height):
# Decode to GL_RGBA
out = (ctypes.c_ubyte * (width * height * 4))()
pitch = width << 2
# Read 16 bytes at a time
image_offset = 0
for (a0, a1, a2, a3, a4, a5, a6, a7,
c0_lo, c0_hi, c1_lo, c1_hi,
b0, b1, b2, b3) in split_16byte.findall(data):
color0 = ord(c0_lo) | ord(c0_hi) << 8
color1 = ord(c1_lo) | ord(c1_hi) << 8
bits = ord(b0) | ord(b1) << 8 | ord(b2) << 16 | ord(b3) << 24
alpha = ord(a0) | ord(a1) << 8 | ord(a2) << 16 | ord(a3) << 24 | \
ord(a4) << 32 | ord(a5) << 40 | ord(a6) << 48 | ord(a7) << 56
r0 = color0 & 0x1f
g0 = (color0 & 0x7e0) >> 5
b0 = (color0 & 0xf800) >> 11
r1 = color1 & 0x1f
g1 = (color1 & 0x7e0) >> 5
b1 = (color1 & 0xf800) >> 11
# i is the dest ptr for this block
i = image_offset
for y in range(4):
for x in range(4):
code = bits & 0x3
a = alpha & 0xf
if code == 0:
r, g, b = r0, g0, b0
elif code == 1:
r, g, b = r1, g1, b1
elif code == 3 and color0 <= color1:
r = g = b = 0
else:
if code == 2 and color0 > color1:
r = (2 * r0 + r1) / 3
g = (2 * g0 + g1) / 3
b = (2 * b0 + b1) / 3
elif code == 3 and color0 > color1:
r = (r0 + 2 * r1) / 3
g = (g0 + 2 * g1) / 3
b = (b0 + 2 * b1) / 3
else:
assert code == 2 and color0 <= color1
r = (r0 + r1) / 2
g = (g0 + g1) / 2
b = (b0 + b1) / 2
out[i] = b << 3
out[i+1] = g << 2
out[i+2] = r << 3
out[i+3] = a << 4
bits >>= 2
alpha >>= 4
i += 4
i += pitch - 16
# Move dest ptr to next 4x4 block
advance_row = (image_offset + 16) % pitch == 0
image_offset += pitch * 3 * advance_row + 16
return PackedImageData(width, height, GL_RGBA, GL_UNSIGNED_BYTE, out)
def decode_dxt5(data, width, height):
# Decode to GL_RGBA
out = (ctypes.c_ubyte * (width * height * 4))()
pitch = width << 2
# Read 16 bytes at a time
image_offset = 0
for (alpha0, alpha1, ab0, ab1, ab2, ab3, ab4, ab5,
c0_lo, c0_hi, c1_lo, c1_hi,
b0, b1, b2, b3) in split_16byte.findall(data):
color0 = ord(c0_lo) | ord(c0_hi) << 8
color1 = ord(c1_lo) | ord(c1_hi) << 8
alpha0 = ord(alpha0)
alpha1 = ord(alpha1)
bits = ord(b0) | ord(b1) << 8 | ord(b2) << 16 | ord(b3) << 24
abits = ord(ab0) | ord(ab1) << 8 | ord(ab2) << 16 | ord(ab3) << 24 | \
ord(ab4) << 32 | ord(ab5) << 40
r0 = color0 & 0x1f
g0 = (color0 & 0x7e0) >> 5
b0 = (color0 & 0xf800) >> 11
r1 = color1 & 0x1f
g1 = (color1 & 0x7e0) >> 5
b1 = (color1 & 0xf800) >> 11
# i is the dest ptr for this block
i = image_offset
for y in range(4):
for x in range(4):
code = bits & 0x3
acode = abits & 0x7
if code == 0:
r, g, b = r0, g0, b0
elif code == 1:
r, g, b = r1, g1, b1
elif code == 3 and color0 <= color1:
r = g = b = 0
else:
if code == 2 and color0 > color1:
r = (2 * r0 + r1) / 3
g = (2 * g0 + g1) / 3
b = (2 * b0 + b1) / 3
elif code == 3 and color0 > color1:
r = (r0 + 2 * r1) / 3
g = (g0 + 2 * g1) / 3
b = (b0 + 2 * b1) / 3
else:
assert code == 2 and color0 <= color1
r = (r0 + r1) / 2
g = (g0 + g1) / 2
b = (b0 + b1) / 2
if acode == 0:
a = alpha0
elif acode == 1:
a = alpha1
elif alpha0 > alpha1:
if acode == 2:
a = (6 * alpha0 + 1 * alpha1) / 7
elif acode == 3:
a = (5 * alpha0 + 2 * alpha1) / 7
elif acode == 4:
a = (4 * alpha0 + 3 * alpha1) / 7
elif acode == 5:
a = (3 * alpha0 + 4 * alpha1) / 7
elif acode == 6:
a = (2 * alpha0 + 5 * alpha1) / 7
else:
assert acode == 7
a = (1 * alpha0 + 6 * alpha1) / 7
else:
if acode == 2:
a = (4 * alpha0 + 1 * alpha1) / 5
elif acode == 3:
a = (3 * alpha0 + 2 * alpha1) / 5
elif acode == 4:
a = (2 * alpha0 + 3 * alpha1) / 5
elif acode == 5:
a = (1 * alpha0 + 4 * alpha1) / 5
elif acode == 6:
a = 0
else:
assert acode == 7
a = 255
out[i] = b << 3
out[i+1] = g << 2
out[i+2] = r << 3
out[i+3] = a
bits >>= 2
abits >>= 3
i += 4
i += pitch - 16
# Move dest ptr to next 4x4 block
advance_row = (image_offset + 16) % pitch == 0
image_offset += pitch * 3 * advance_row + 16
return PackedImageData(width, height, GL_RGBA, GL_UNSIGNED_BYTE, out)
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
from pyglet.gl import *
from pyglet.image import *
from pyglet.image.codecs import *
from pyglet.image.codecs import gif
import pyglet.lib
import pyglet.window
gdk = pyglet.lib.load_library('gdk-x11-2.0')
gdkpixbuf = pyglet.lib.load_library('gdk_pixbuf-2.0')
GdkPixbufLoader = c_void_p
GdkPixbuf = c_void_p
gdkpixbuf.gdk_pixbuf_loader_new.restype = GdkPixbufLoader
gdkpixbuf.gdk_pixbuf_loader_get_pixbuf.restype = GdkPixbuf
gdkpixbuf.gdk_pixbuf_get_pixels.restype = c_void_p
gdkpixbuf.gdk_pixbuf_loader_get_animation.restype = c_void_p
gdkpixbuf.gdk_pixbuf_animation_get_iter.restype = c_void_p
gdkpixbuf.gdk_pixbuf_animation_iter_get_pixbuf.restype = GdkPixbuf
class GTimeVal(Structure):
_fields_ = [
('tv_sec', c_long),
('tv_usec', c_long)
]
class GdkPixbuf2ImageDecoder(ImageDecoder):
def get_file_extensions(self):
return ['.png', '.xpm', '.jpg', '.jpeg', '.tif', '.tiff', '.pnm',
'.ras', '.bmp', '.gif']
def get_animation_file_extensions(self):
return ['.gif', '.ani']
def _load(self, file, filename, load_func):
data = file.read()
loader = gdkpixbuf.gdk_pixbuf_loader_new()
gdkpixbuf.gdk_pixbuf_loader_write(loader, data, len(data), None)
if not gdkpixbuf.gdk_pixbuf_loader_close(loader, None):
raise ImageDecodeException(filename)
result = load_func(loader)
if not result:
raise ImageDecodeException('Unable to load: %s' % filename)
return result
def _pixbuf_to_image(self, pixbuf):
# Get format and dimensions
width = gdkpixbuf.gdk_pixbuf_get_width(pixbuf)
height = gdkpixbuf.gdk_pixbuf_get_height(pixbuf)
channels = gdkpixbuf.gdk_pixbuf_get_n_channels(pixbuf)
rowstride = gdkpixbuf.gdk_pixbuf_get_rowstride(pixbuf)
#has_alpha = gdkpixbuf.gdk_pixbuf_get_has_alpha(pixbuf)
pixels = gdkpixbuf.gdk_pixbuf_get_pixels(pixbuf)
# Copy pixel data.
buffer = (c_ubyte * (rowstride * height))()
memmove(buffer, pixels, rowstride * (height - 1) + width * channels)
# Release pixbuf
gdk.g_object_unref(pixbuf)
# Determine appropriate GL type
if channels == 3:
format = 'RGB'
else:
format = 'RGBA'
return ImageData(width, height, format, buffer, -rowstride)
def decode(self, file, filename):
pixbuf = self._load(file, filename,
gdkpixbuf.gdk_pixbuf_loader_get_pixbuf)
return self._pixbuf_to_image(pixbuf)
def decode_animation(self, file, filename):
# Extract GIF control data. If it's not a GIF, this method will
# raise.
gif_stream = gif.read(file)
delays = [image.delay for image in gif_stream.images]
# Get GDK animation iterator
file.seek(0)
anim = self._load(file, filename,
gdkpixbuf.gdk_pixbuf_loader_get_animation)
time = GTimeVal(0, 0)
iter = gdkpixbuf.gdk_pixbuf_animation_get_iter(anim, byref(time))
frames = []
# Extract each image
for control_delay in delays:
pixbuf = gdkpixbuf.gdk_pixbuf_animation_iter_get_pixbuf(iter)
# When attempting to load animated gifs with an alpha channel on
# linux gdkpixbuf will normally return a null pixbuf for the final
# frame resulting in a segfault:
# http://code.google.com/p/pyglet/issues/detail?id=411
# Since it is unclear why exactly this happens, the workaround
# below is to start again and extract that frame on its own.
if pixbuf == None:
file.seek(0)
anim = self._load(file, filename,
gdkpixbuf.gdk_pixbuf_loader_get_animation)
temptime = GTimeVal(0, 0)
iter = gdkpixbuf.gdk_pixbuf_animation_get_iter(anim, byref(temptime))
gdkpixbuf.gdk_pixbuf_animation_iter_advance(iter, byref(time))
pixbuf = gdkpixbuf.gdk_pixbuf_animation_iter_get_pixbuf(iter)
image = self._pixbuf_to_image(pixbuf)
frames.append(AnimationFrame(image, control_delay))
gdk_delay = gdkpixbuf.gdk_pixbuf_animation_iter_get_delay_time(iter)
if gdk_delay == -1:
break
gdk_delay = gdkpixbuf.gdk_pixbuf_animation_iter_get_delay_time(iter)
gdk_delay *= 1000 # milliseconds to microseconds
# Compare gdk_delay to control_delay for interest only.
#print control_delay, gdk_delay / 1000000.
us = time.tv_usec + gdk_delay
time.tv_sec += us // 1000000
time.tv_usec = us % 1000000
gdkpixbuf.gdk_pixbuf_animation_iter_advance(iter, byref(time))
return Animation(frames)
def get_decoders():
return [GdkPixbuf2ImageDecoder()]
def get_encoders():
return []
def init():
gdk.g_type_init()
init()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Read GIF control data.
http://www.w3.org/Graphics/GIF/spec-gif89a.txt
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import struct
from pyglet.image.codecs import ImageDecodeException
class GIFStream(object):
def __init__(self):
self.images = []
class GIFImage(object):
delay = None
class GraphicsScope(object):
delay = None
# Appendix A.
LABEL_EXTENSION_INTRODUCER = 0x21
LABEL_GRAPHIC_CONTROL_EXTENSION = 0xf9
LABEL_IMAGE_DESCRIPTOR = 0x2c
LABEL_TRAILER = 0x3b
def unpack(format, file):
size = struct.calcsize(format)
data = file.read(size)
if len(data) < size:
raise ImageDecodeException('Unexpected EOF')
return struct.unpack(format, data)
def read_byte(file):
data = file.read(1)
if not len(data):
raise ImageDecodeException('Unexpected EOF')
return ord(data)
def read(file):
'''Read a GIF file stream.
:rtype: GIFStream
'''
# 17. Header
signature = file.read(3)
version = file.read(3)
if signature != b'GIF':
raise ImageDecodeException('Not a GIF stream')
stream = GIFStream()
# 18. Logical screen descriptor
(logical_screen_width,
logical_screen_height,
fields,
background_color_index,
pixel_aspect_ratio) = unpack('HHBBB', file)
global_color_table_flag = fields & 0x80
global_color_table_size = fields & 0x7
# 19. Global color table
if global_color_table_flag:
global_color_table = file.read(6 << global_color_table_size)
# <Data>*
graphics_scope = GraphicsScope()
block_type = read_byte(file)
while block_type != LABEL_TRAILER:
if block_type == LABEL_IMAGE_DESCRIPTOR:
read_table_based_image(file, stream, graphics_scope)
graphics_scope = GraphicsScope()
elif block_type == LABEL_EXTENSION_INTRODUCER:
extension_block_type = read_byte(file)
if extension_block_type == LABEL_GRAPHIC_CONTROL_EXTENSION:
read_graphic_control_extension(file, stream, graphics_scope)
else:
skip_data_sub_blocks(file)
else:
# Skip bytes until a valid start character is found
print block_type
pass
block_type = read_byte(file)
return stream
def skip_data_sub_blocks(file):
# 15. Data sub-blocks
block_size = read_byte(file)
while block_size != 0:
data = file.read(block_size)
block_size = read_byte(file)
def read_table_based_image(file, stream, graphics_scope):
gif_image = GIFImage()
stream.images.append(gif_image)
gif_image.delay = graphics_scope.delay
# 20. Image descriptor
(image_left_position,
image_top_position,
image_width,
image_height,
fields) = unpack('HHHHB', file)
local_color_table_flag = fields & 0x80
local_color_table_size = fields & 0x7
# 21. Local color table
if local_color_table_flag:
local_color_table = file.read(6 << local_color_table_size)
# 22. Table based image data
lzw_code_size = file.read(1)
skip_data_sub_blocks(file)
def read_graphic_control_extension(file, stream, graphics_scope):
# 23. Graphic control extension
(block_size,
fields,
delay_time,
transparent_color_index,
terminator) = unpack('BBHBB', file)
if block_size != 4:
raise ImageDecodeException('Incorrect block size')
if delay_time:
# Follow Firefox/Mac behaviour: use 100ms delay for any delay
# less than 10ms.
if delay_time <= 1:
delay_time = 10
graphics_scope.delay = float(delay_time) / 100
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Collection of image encoders and decoders.
Modules must subclass ImageDecoder and ImageEncoder for each method of
decoding/encoding they support.
Modules must also implement the two functions::
def get_decoders():
# Return a list of ImageDecoder instances or []
return []
def get_encoders():
# Return a list of ImageEncoder instances or []
return []
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id: $'
import os.path
from pyglet import compat_platform
_decoders = [] # List of registered ImageDecoders
_decoder_extensions = {} # Map str -> list of matching ImageDecoders
_decoder_animation_extensions = {}
# Map str -> list of matching ImageDecoders
_encoders = [] # List of registered ImageEncoders
_encoder_extensions = {} # Map str -> list of matching ImageEncoders
class ImageDecodeException(Exception):
exception_priority = 10
class ImageEncodeException(Exception):
pass
class ImageDecoder(object):
def get_file_extensions(self):
'''Return a list of accepted file extensions, e.g. ['.png', '.bmp']
Lower-case only.
'''
return []
def get_animation_file_extensions(self):
'''Return a list of accepted file extensions, e.g. ['.gif', '.flc']
Lower-case only.
'''
return []
def decode(self, file, filename):
'''Decode the given file object and return an instance of `Image`.
Throws ImageDecodeException if there is an error. filename
can be a file type hint.
'''
raise NotImplementedError()
def decode_animation(self, file, filename):
'''Decode the given file object and return an instance of `Animation`.
Throws ImageDecodeException if there is an error. filename
can be a file type hint.
'''
raise ImageDecodeException('This decoder cannot decode animations.')
class ImageEncoder(object):
def get_file_extensions(self):
'''Return a list of accepted file extensions, e.g. ['.png', '.bmp']
Lower-case only.
'''
return []
def encode(self, image, file, filename, options={}):
'''Encode the given image to the given file. filename
provides a hint to the file format desired. options are
encoder-specific, and unknown options should be ignored or
issue warnings.
'''
raise NotImplementedError()
def get_encoders(filename=None):
'''Get an ordered list of encoders to attempt. filename can be used
as a hint for the filetype.
'''
encoders = []
if filename:
extension = os.path.splitext(filename)[1].lower()
encoders += _encoder_extensions.get(extension, [])
encoders += [e for e in _encoders if e not in encoders]
return encoders
def get_decoders(filename=None):
'''Get an ordered list of decoders to attempt. filename can be used
as a hint for the filetype.
'''
decoders = []
if filename:
extension = os.path.splitext(filename)[1].lower()
decoders += _decoder_extensions.get(extension, [])
decoders += [e for e in _decoders if e not in decoders]
return decoders
def get_animation_decoders(filename=None):
'''Get an ordered list of decoders to attempt. filename can be used
as a hint for the filetype.
'''
decoders = []
if filename:
extension = os.path.splitext(filename)[1].lower()
decoders += _decoder_animation_extensions.get(extension, [])
decoders += [e for e in _decoders if e not in decoders]
return decoders
def add_decoders(module):
'''Add a decoder module. The module must define `get_decoders`. Once
added, the appropriate decoders defined in the codec will be returned by
pyglet.image.codecs.get_decoders.
'''
for decoder in module.get_decoders():
_decoders.append(decoder)
for extension in decoder.get_file_extensions():
if extension not in _decoder_extensions:
_decoder_extensions[extension] = []
_decoder_extensions[extension].append(decoder)
for extension in decoder.get_animation_file_extensions():
if extension not in _decoder_animation_extensions:
_decoder_animation_extensions[extension] = []
_decoder_animation_extensions[extension].append(decoder)
def add_encoders(module):
'''Add an encoder module. The module must define `get_encoders`. Once
added, the appropriate encoders defined in the codec will be returned by
pyglet.image.codecs.get_encoders.
'''
for encoder in module.get_encoders():
_encoders.append(encoder)
for extension in encoder.get_file_extensions():
if extension not in _encoder_extensions:
_encoder_extensions[extension] = []
_encoder_extensions[extension].append(encoder)
def add_default_image_codecs():
# Add the codecs we know about. These should be listed in order of
# preference. This is called automatically by pyglet.image.
# Compressed texture in DDS format
try:
from pyglet.image.codecs import dds
add_encoders(dds)
add_decoders(dds)
except ImportError:
pass
# Mac OS X default: Quicktime for Carbon, Quartz for Cocoa.
# TODO: Make ctypes Quartz the default for both Carbon & Cocoa.
if compat_platform == 'darwin':
try:
from pyglet import options as pyglet_options
if pyglet_options['darwin_cocoa']:
import pyglet.image.codecs.quartz
add_encoders(quartz)
add_decoders(quartz)
else:
import pyglet.image.codecs.quicktime
add_encoders(quicktime)
add_decoders(quicktime)
except ImportError:
pass
# Windows XP default: GDI+
if compat_platform in ('win32', 'cygwin'):
try:
import pyglet.image.codecs.gdiplus
add_encoders(gdiplus)
add_decoders(gdiplus)
except ImportError:
pass
# Linux default: GdkPixbuf 2.0
if compat_platform.startswith('linux'):
try:
import pyglet.image.codecs.gdkpixbuf2
add_encoders(gdkpixbuf2)
add_decoders(gdkpixbuf2)
except ImportError:
pass
# Fallback: PIL
try:
import pyglet.image.codecs.pil
add_encoders(pil)
add_decoders(pil)
except ImportError:
pass
# Fallback: PNG loader (slow)
try:
import pyglet.image.codecs.png
add_encoders(png)
add_decoders(png)
except ImportError:
pass
# Fallback: BMP loader (slow)
try:
import pyglet.image.codecs.bmp
add_encoders(bmp)
add_decoders(bmp)
except ImportError:
pass
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''
'''
from __future__ import absolute_import
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import os.path
from pyglet.gl import *
from pyglet.image import *
from pyglet.image.codecs import *
try:
import Image
except ImportError:
from PIL import Image
class PILImageDecoder(ImageDecoder):
def get_file_extensions(self):
# Only most common ones shown here
return ['.bmp', '.cur', '.gif', '.ico', '.jpg', '.jpeg', '.pcx', '.png',
'.tga', '.tif', '.tiff', '.xbm', '.xpm']
def decode(self, file, filename):
try:
image = Image.open(file)
except Exception, e:
raise ImageDecodeException(
'PIL cannot read %r: %s' % (filename or file, e))
try:
image = image.transpose(Image.FLIP_TOP_BOTTOM)
except Exception, e:
raise ImageDecodeException(
'PIL failed to transpose %r: %s' % (filename or file, e))
# Convert bitmap and palette images to component
if image.mode in ('1', 'P'):
image = image.convert()
if image.mode not in ('L', 'LA', 'RGB', 'RGBA'):
raise ImageDecodeException('Unsupported mode "%s"' % image.mode)
type = GL_UNSIGNED_BYTE
width, height = image.size
# tostring is deprecated, replaced by tobytes in Pillow (PIL fork)
# (1.1.7) PIL still uses it
image_data_fn = getattr(image, "tobytes", getattr(image, "tostring"))
return ImageData(width, height, image.mode, image_data_fn())
class PILImageEncoder(ImageEncoder):
def get_file_extensions(self):
# Most common only
return ['.bmp', '.eps', '.gif', '.jpg', '.jpeg',
'.pcx', '.png', '.ppm', '.tiff', '.xbm']
def encode(self, image, file, filename):
# File format is guessed from filename extension, otherwise defaults
# to PNG.
pil_format = (filename and os.path.splitext(filename)[1][1:]) or 'png'
if pil_format.lower() == 'jpg':
pil_format = 'JPEG'
image = image.get_image_data()
format = image.format
if format != 'RGB':
# Only save in RGB or RGBA formats.
format = 'RGBA'
pitch = -(image.width * len(format))
# fromstring is deprecated, replaced by frombytes in Pillow (PIL fork)
# (1.1.7) PIL still uses it
image_from_fn = getattr(Image, "frombytes", getattr(Image, "fromstring"))
pil_image = image_from_fn(
format, (image.width, image.height), image.get_data(format, pitch))
try:
pil_image.save(file, pil_format)
except Exception, e:
raise ImageEncodeException(e)
def get_decoders():
return [PILImageDecoder()]
def get_encoders():
return [PILImageEncoder()]
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
# png.py - PNG encoder in pure Python
# Copyright (C) 2006 Johann C. Rocholl <johann@browsershots.org>
# <ah> Modifications for pyglet by Alex Holkner <alex.holkner@gmail.com>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Contributors (alphabetical):
# Nicko van Someren <nicko@nicko.org>
#
# Changelog (recent first):
# 2006-06-17 Nicko: Reworked into a class, faster interlacing.
# 2006-06-17 Johann: Very simple prototype PNG decoder.
# 2006-06-17 Nicko: Test suite with various image generators.
# 2006-06-17 Nicko: Alpha-channel, grey-scale, 16-bit/plane support.
# 2006-06-15 Johann: Scanline iterator interface for large input files.
# 2006-06-09 Johann: Very simple prototype PNG encoder.
"""
Pure Python PNG Reader/Writer
This is an implementation of a subset of the PNG specification at
http://www.w3.org/TR/2003/REC-PNG-20031110 in pure Python. It reads
and writes PNG files with 8/16/24/32/48/64 bits per pixel (greyscale,
RGB, RGBA, with 8 or 16 bits per layer), with a number of options. For
help, type "import png; help(png)" in your python interpreter.
This file can also be used as a command-line utility to convert PNM
files to PNG. The interface is similar to that of the pnmtopng program
from the netpbm package. Type "python png.py --help" at the shell
prompt for usage and a list of options.
"""
__revision__ = '$Rev$'
__date__ = '$Date$'
__author__ = '$Author$'
import sys
import zlib
import struct
import math
from array import array
from pyglet.compat import asbytes
_adam7 = ((0, 0, 8, 8),
(4, 0, 8, 8),
(0, 4, 4, 8),
(2, 0, 4, 4),
(0, 2, 2, 4),
(1, 0, 2, 2),
(0, 1, 1, 2))
# Conditionally convert to bytes. Works on Python 2 and Python 3.
try:
bytes('', 'ascii')
def strtobytes(x): return bytes(x, 'iso8859-1')
except (NameError, TypeError):
strtobytes = str
def interleave_planes(ipixels, apixels, ipsize, apsize):
"""
Interleave color planes, e.g. RGB + A = RGBA.
Return an array of pixels consisting of the ipsize bytes of data
from each pixel in ipixels followed by the apsize bytes of data
from each pixel in apixels, for an image of size width x height.
"""
itotal = len(ipixels)
atotal = len(apixels)
newtotal = itotal + atotal
newpsize = ipsize + apsize
# Set up the output buffer
out = array('B')
# It's annoying that there is no cheap way to set the array size :-(
out.extend(ipixels)
out.extend(apixels)
# Interleave in the pixel data
for i in range(ipsize):
out[i:newtotal:newpsize] = ipixels[i:itotal:ipsize]
for i in range(apsize):
out[i+ipsize:newtotal:newpsize] = apixels[i:atotal:apsize]
return out
class Error(Exception):
pass
class Writer:
"""
PNG encoder in pure Python.
"""
def __init__(self, width, height,
transparent=None,
background=None,
gamma=None,
greyscale=False,
has_alpha=False,
bytes_per_sample=1,
compression=None,
interlaced=False,
chunk_limit=2**20):
"""
Create a PNG encoder object.
Arguments:
width, height - size of the image in pixels
transparent - create a tRNS chunk
background - create a bKGD chunk
gamma - create a gAMA chunk
greyscale - input data is greyscale, not RGB
has_alpha - input data has alpha channel (RGBA)
bytes_per_sample - 8-bit or 16-bit input data
compression - zlib compression level (1-9)
chunk_limit - write multiple IDAT chunks to save memory
If specified, the transparent and background parameters must
be a tuple with three integer values for red, green, blue, or
a simple integer (or singleton tuple) for a greyscale image.
If specified, the gamma parameter must be a float value.
"""
if width <= 0 or height <= 0:
raise ValueError("width and height must be greater than zero")
if has_alpha and transparent is not None:
raise ValueError(
"transparent color not allowed with alpha channel")
if bytes_per_sample < 1 or bytes_per_sample > 2:
raise ValueError("bytes per sample must be 1 or 2")
if transparent is not None:
if greyscale:
if type(transparent) is not int:
raise ValueError(
"transparent color for greyscale must be integer")
else:
if not (len(transparent) == 3 and
type(transparent[0]) is int and
type(transparent[1]) is int and
type(transparent[2]) is int):
raise ValueError(
"transparent color must be a triple of integers")
if background is not None:
if greyscale:
if type(background) is not int:
raise ValueError(
"background color for greyscale must be integer")
else:
if not (len(background) == 3 and
type(background[0]) is int and
type(background[1]) is int and
type(background[2]) is int):
raise ValueError(
"background color must be a triple of integers")
self.width = width
self.height = height
self.transparent = transparent
self.background = background
self.gamma = gamma
self.greyscale = greyscale
self.has_alpha = has_alpha
self.bytes_per_sample = bytes_per_sample
self.compression = compression
self.chunk_limit = chunk_limit
self.interlaced = interlaced
if self.greyscale:
self.color_depth = 1
if self.has_alpha:
self.color_type = 4
self.psize = self.bytes_per_sample * 2
else:
self.color_type = 0
self.psize = self.bytes_per_sample
else:
self.color_depth = 3
if self.has_alpha:
self.color_type = 6
self.psize = self.bytes_per_sample * 4
else:
self.color_type = 2
self.psize = self.bytes_per_sample * 3
def write_chunk(self, outfile, tag, data):
"""
Write a PNG chunk to the output file, including length and checksum.
"""
# http://www.w3.org/TR/PNG/#5Chunk-layout
tag = asbytes(tag)
data = asbytes(data)
outfile.write(struct.pack("!I", len(data)))
outfile.write(tag)
outfile.write(data)
checksum = zlib.crc32(tag)
checksum = zlib.crc32(data, checksum)
# <ah> Avoid DeprecationWarning: struct integer overflow masking
# with Python2.5/Windows.
checksum = checksum & 0xffffffff
outfile.write(struct.pack("!I", checksum))
def write(self, outfile, scanlines):
"""
Write a PNG image to the output file.
"""
# http://www.w3.org/TR/PNG/#5PNG-file-signature
outfile.write(struct.pack("8B", 137, 80, 78, 71, 13, 10, 26, 10))
# http://www.w3.org/TR/PNG/#11IHDR
if self.interlaced:
interlaced = 1
else:
interlaced = 0
self.write_chunk(outfile, 'IHDR',
struct.pack("!2I5B", self.width, self.height,
self.bytes_per_sample * 8,
self.color_type, 0, 0, interlaced))
# http://www.w3.org/TR/PNG/#11tRNS
if self.transparent is not None:
if self.greyscale:
self.write_chunk(outfile, 'tRNS',
struct.pack("!1H", *self.transparent))
else:
self.write_chunk(outfile, 'tRNS',
struct.pack("!3H", *self.transparent))
# http://www.w3.org/TR/PNG/#11bKGD
if self.background is not None:
if self.greyscale:
self.write_chunk(outfile, 'bKGD',
struct.pack("!1H", *self.background))
else:
self.write_chunk(outfile, 'bKGD',
struct.pack("!3H", *self.background))
# http://www.w3.org/TR/PNG/#11gAMA
if self.gamma is not None:
self.write_chunk(outfile, 'gAMA',
struct.pack("!L", int(self.gamma * 100000)))
# http://www.w3.org/TR/PNG/#11IDAT
if self.compression is not None:
compressor = zlib.compressobj(self.compression)
else:
compressor = zlib.compressobj()
data = array('B')
for scanline in scanlines:
data.append(0)
data.extend(scanline)
if len(data) > self.chunk_limit:
compressed = compressor.compress(data.tostring())
if len(compressed):
# print >> sys.stderr, len(data), len(compressed)
self.write_chunk(outfile, 'IDAT', compressed)
data = array('B')
if len(data):
compressed = compressor.compress(data.tostring())
else:
compressed = strtobytes('')
flushed = compressor.flush()
if len(compressed) or len(flushed):
# print >> sys.stderr, len(data), len(compressed), len(flushed)
self.write_chunk(outfile, 'IDAT', compressed + flushed)
# http://www.w3.org/TR/PNG/#11IEND
self.write_chunk(outfile, 'IEND', '')
def write_array(self, outfile, pixels):
"""
Encode a pixel array to PNG and write output file.
"""
if self.interlaced:
self.write(outfile, self.array_scanlines_interlace(pixels))
else:
self.write(outfile, self.array_scanlines(pixels))
def convert_ppm(self, ppmfile, outfile):
"""
Convert a PPM file containing raw pixel data into a PNG file
with the parameters set in the writer object.
"""
if self.interlaced:
pixels = array('B')
pixels.fromfile(ppmfile,
self.bytes_per_sample * self.color_depth *
self.width * self.height)
self.write(outfile, self.array_scanlines_interlace(pixels))
else:
self.write(outfile, self.file_scanlines(ppmfile))
def convert_ppm_and_pgm(self, ppmfile, pgmfile, outfile):
"""
Convert a PPM and PGM file containing raw pixel data into a
PNG outfile with the parameters set in the writer object.
"""
pixels = array('B')
pixels.fromfile(ppmfile,
self.bytes_per_sample * self.color_depth *
self.width * self.height)
apixels = array('B')
apixels.fromfile(pgmfile,
self.bytes_per_sample *
self.width * self.height)
pixels = interleave_planes(pixels, apixels,
self.bytes_per_sample * self.color_depth,
self.bytes_per_sample)
if self.interlaced:
self.write(outfile, self.array_scanlines_interlace(pixels))
else:
self.write(outfile, self.array_scanlines(pixels))
def file_scanlines(self, infile):
"""
Generator for scanlines from an input file.
"""
row_bytes = self.psize * self.width
for y in range(self.height):
scanline = array('B')
scanline.fromfile(infile, row_bytes)
yield scanline
def array_scanlines(self, pixels):
"""
Generator for scanlines from an array.
"""
row_bytes = self.width * self.psize
stop = 0
for y in range(self.height):
start = stop
stop = start + row_bytes
yield pixels[start:stop]
def old_array_scanlines_interlace(self, pixels):
"""
Generator for interlaced scanlines from an array.
http://www.w3.org/TR/PNG/#8InterlaceMethods
"""
row_bytes = self.psize * self.width
for xstart, ystart, xstep, ystep in _adam7:
for y in range(ystart, self.height, ystep):
if xstart < self.width:
if xstep == 1:
offset = y*row_bytes
yield pixels[offset:offset+row_bytes]
else:
row = array('B')
offset = y*row_bytes + xstart* self.psize
skip = self.psize * xstep
for x in range(xstart, self.width, xstep):
row.extend(pixels[offset:offset + self.psize])
offset += skip
yield row
def array_scanlines_interlace(self, pixels):
"""
Generator for interlaced scanlines from an array.
http://www.w3.org/TR/PNG/#8InterlaceMethods
"""
row_bytes = self.psize * self.width
for xstart, ystart, xstep, ystep in _adam7:
for y in range(ystart, self.height, ystep):
if xstart >= self.width:
continue
if xstep == 1:
offset = y * row_bytes
yield pixels[offset:offset+row_bytes]
else:
row = array('B')
# Note we want the ceiling of (self.width - xstart) / xtep
row_len = self.psize * (
(self.width - xstart + xstep - 1) / xstep)
# There's no easier way to set the length of an array
row.extend(pixels[0:row_len])
offset = y * row_bytes + xstart * self.psize
end_offset = (y+1) * row_bytes
skip = self.psize * xstep
for i in range(self.psize):
row[i:row_len:self.psize] = \
pixels[offset+i:end_offset:skip]
yield row
class _readable:
"""
A simple file-like interface for strings and arrays.
"""
def __init__(self, buf):
self.buf = buf
self.offset = 0
def read(self, n):
r = self.buf[offset:offset+n]
if isinstance(r, array):
r = r.tostring()
self.offset += n
return r
class Reader:
"""
PNG decoder in pure Python.
"""
def __init__(self, _guess=None, **kw):
"""
Create a PNG decoder object.
The constructor expects exactly one keyword argument. If you
supply a positional argument instead, it will guess the input
type. You can choose among the following arguments:
filename - name of PNG input file
file - object with a read() method
pixels - array or string with PNG data
"""
if ((_guess is not None and len(kw) != 0) or
(_guess is None and len(kw) != 1)):
raise TypeError("Reader() takes exactly 1 argument")
if _guess is not None:
if isinstance(_guess, array):
kw["pixels"] = _guess
elif isinstance(_guess, str):
kw["filename"] = _guess
elif isinstance(_guess, file):
kw["file"] = _guess
if "filename" in kw:
self.file = file(kw["filename"])
elif "file" in kw:
self.file = kw["file"]
elif "pixels" in kw:
self.file = _readable(kw["pixels"])
else:
raise TypeError("expecting filename, file or pixels array")
def read_chunk(self):
"""
Read a PNG chunk from the input file, return tag name and data.
"""
# http://www.w3.org/TR/PNG/#5Chunk-layout
try:
data_bytes, tag = struct.unpack('!I4s', self.file.read(8))
except struct.error:
raise ValueError('Chunk too short for header')
data = self.file.read(data_bytes)
if len(data) != data_bytes:
raise ValueError('Chunk %s too short for required %i data octets'
% (tag, data_bytes))
checksum = self.file.read(4)
if len(checksum) != 4:
raise ValueError('Chunk %s too short for checksum', tag)
verify = zlib.crc32(tag)
verify = zlib.crc32(data, verify)
# Whether the output from zlib.crc32 is signed or not varies
# according to hideous implementation details, see
# http://bugs.python.org/issue1202 .
# We coerce it to be positive here (in a way which works on
# Python 2.3 and older).
verify &= 2**32 - 1
verify = struct.pack('!I', verify)
if checksum != verify:
# print repr(checksum)
(a,) = struct.unpack('!I', checksum)
(b,) = struct.unpack('!I', verify)
raise ValueError("Checksum error in %s chunk: 0x%X != 0x%X"
% (tag, a, b))
return tag, data
def _reconstruct_sub(self, offset, xstep, ystep):
"""
Reverse sub filter.
"""
pixels = self.pixels
a_offset = offset
offset += self.psize * xstep
if xstep == 1:
for index in range(self.psize, self.row_bytes):
x = pixels[offset]
a = pixels[a_offset]
pixels[offset] = (x + a) & 0xff
offset += 1
a_offset += 1
else:
byte_step = self.psize * xstep
for index in range(byte_step, self.row_bytes, byte_step):
for i in range(self.psize):
x = pixels[offset + i]
a = pixels[a_offset + i]
pixels[offset + i] = (x + a) & 0xff
offset += self.psize * xstep
a_offset += self.psize * xstep
def _reconstruct_up(self, offset, xstep, ystep):
"""
Reverse up filter.
"""
pixels = self.pixels
b_offset = offset - (self.row_bytes * ystep)
if xstep == 1:
for index in range(self.row_bytes):
x = pixels[offset]
b = pixels[b_offset]
pixels[offset] = (x + b) & 0xff
offset += 1
b_offset += 1
else:
for index in range(0, self.row_bytes, xstep * self.psize):
for i in range(self.psize):
x = pixels[offset + i]
b = pixels[b_offset + i]
pixels[offset + i] = (x + b) & 0xff
offset += self.psize * xstep
b_offset += self.psize * xstep
def _reconstruct_average(self, offset, xstep, ystep):
"""
Reverse average filter.
"""
pixels = self.pixels
a_offset = offset - (self.psize * xstep)
b_offset = offset - (self.row_bytes * ystep)
if xstep == 1:
for index in range(self.row_bytes):
x = pixels[offset]
if index < self.psize:
a = 0
else:
a = pixels[a_offset]
if b_offset < 0:
b = 0
else:
b = pixels[b_offset]
pixels[offset] = (x + ((a + b) >> 1)) & 0xff
offset += 1
a_offset += 1
b_offset += 1
else:
for index in range(0, self.row_bytes, self.psize * xstep):
for i in range(self.psize):
x = pixels[offset+i]
if index < self.psize:
a = 0
else:
a = pixels[a_offset + i]
if b_offset < 0:
b = 0
else:
b = pixels[b_offset + i]
pixels[offset + i] = (x + ((a + b) >> 1)) & 0xff
offset += self.psize * xstep
a_offset += self.psize * xstep
b_offset += self.psize * xstep
def _reconstruct_paeth(self, offset, xstep, ystep):
"""
Reverse Paeth filter.
"""
pixels = self.pixels
a_offset = offset - (self.psize * xstep)
b_offset = offset - (self.row_bytes * ystep)
c_offset = b_offset - (self.psize * xstep)
# There's enough inside this loop that it's probably not worth
# optimising for xstep == 1
for index in range(0, self.row_bytes, self.psize * xstep):
for i in range(self.psize):
x = pixels[offset+i]
if index < self.psize:
a = c = 0
b = pixels[b_offset+i]
else:
a = pixels[a_offset+i]
b = pixels[b_offset+i]
c = pixels[c_offset+i]
p = a + b - c
pa = abs(p - a)
pb = abs(p - b)
pc = abs(p - c)
if pa <= pb and pa <= pc:
pr = a
elif pb <= pc:
pr = b
else:
pr = c
pixels[offset+i] = (x + pr) & 0xff
offset += self.psize * xstep
a_offset += self.psize * xstep
b_offset += self.psize * xstep
c_offset += self.psize * xstep
# N.B. PNG files with 'up', 'average' or 'paeth' filters on the
# first line of a pass are legal. The code above for 'average'
# deals with this case explicitly. For up we map to the null
# filter and for paeth we map to the sub filter.
def reconstruct_line(self, filter_type, first_line, offset, xstep, ystep):
# print >> sys.stderr, "Filter type %s, first_line=%s" % (
# filter_type, first_line)
filter_type += (first_line << 8)
if filter_type == 1 or filter_type == 0x101 or filter_type == 0x104:
self._reconstruct_sub(offset, xstep, ystep)
elif filter_type == 2:
self._reconstruct_up(offset, xstep, ystep)
elif filter_type == 3 or filter_type == 0x103:
self._reconstruct_average(offset, xstep, ystep)
elif filter_type == 4:
self._reconstruct_paeth(offset, xstep, ystep)
return
def deinterlace(self, scanlines):
# print >> sys.stderr, ("Reading interlaced, w=%s, r=%s, planes=%s," +
# " bpp=%s") % (self.width, self.height, self.planes, self.bps)
a = array('B')
self.pixels = a
# Make the array big enough
temp = scanlines[0:self.width*self.height*self.psize]
a.extend(temp)
source_offset = 0
for xstart, ystart, xstep, ystep in _adam7:
# print >> sys.stderr, "Adam7: start=%s,%s step=%s,%s" % (
# xstart, ystart, xstep, ystep)
filter_first_line = 1
for y in range(ystart, self.height, ystep):
if xstart >= self.width:
continue
filter_type = scanlines[source_offset]
source_offset += 1
if xstep == 1:
offset = y * self.row_bytes
a[offset:offset+self.row_bytes] = \
scanlines[source_offset:source_offset + self.row_bytes]
source_offset += self.row_bytes
else:
# Note we want the ceiling of (width - xstart) / xtep
row_len = self.psize * (
(self.width - xstart + xstep - 1) / xstep)
offset = y * self.row_bytes + xstart * self.psize
end_offset = (y+1) * self.row_bytes
skip = self.psize * xstep
for i in range(self.psize):
a[offset+i:end_offset:skip] = \
scanlines[source_offset + i:
source_offset + row_len:
self.psize]
source_offset += row_len
if filter_type:
self.reconstruct_line(filter_type, filter_first_line,
offset, xstep, ystep)
filter_first_line = 0
return a
def read_flat(self, scanlines):
a = array('B')
self.pixels = a
offset = 0
source_offset = 0
filter_first_line = 1
for y in range(self.height):
filter_type = scanlines[source_offset]
source_offset += 1
a.extend(scanlines[source_offset: source_offset + self.row_bytes])
if filter_type:
self.reconstruct_line(filter_type, filter_first_line,
offset, 1, 1)
filter_first_line = 0
offset += self.row_bytes
source_offset += self.row_bytes
return a
def read(self):
"""
Read a simple PNG file, return width, height, pixels and image metadata
This function is a very early prototype with limited flexibility
and excessive use of memory.
"""
signature = self.file.read(8)
if (signature != struct.pack("8B", 137, 80, 78, 71, 13, 10, 26, 10)):
raise Error("PNG file has invalid header")
compressed = []
image_metadata = {}
while True:
try:
tag, data = self.read_chunk()
except ValueError, e:
raise Error('Chunk error: ' + e.args[0])
# print >> sys.stderr, tag, len(data)
if tag == asbytes('IHDR'): # http://www.w3.org/TR/PNG/#11IHDR
(width, height, bits_per_sample, color_type,
compression_method, filter_method,
interlaced) = struct.unpack("!2I5B", data)
bps = bits_per_sample // 8
if bps == 0:
raise Error("unsupported pixel depth")
if bps > 2 or bits_per_sample != (bps * 8):
raise Error("invalid pixel depth")
if color_type == 0:
greyscale = True
has_alpha = False
has_palette = False
planes = 1
elif color_type == 2:
greyscale = False
has_alpha = False
has_palette = False
planes = 3
elif color_type == 3:
greyscale = False
has_alpha = False
has_palette = True
planes = 1
elif color_type == 4:
greyscale = True
has_alpha = True
has_palette = False
planes = 2
elif color_type == 6:
greyscale = False
has_alpha = True
has_palette = False
planes = 4
else:
raise Error("unknown PNG colour type %s" % color_type)
if compression_method != 0:
raise Error("unknown compression method")
if filter_method != 0:
raise Error("unknown filter method")
self.bps = bps
self.planes = planes
self.psize = bps * planes
self.width = width
self.height = height
self.row_bytes = width * self.psize
elif tag == asbytes('IDAT'): # http://www.w3.org/TR/PNG/#11IDAT
compressed.append(data)
elif tag == asbytes('bKGD'):
if greyscale:
image_metadata["background"] = struct.unpack("!1H", data)
elif has_palette:
image_metadata["background"] = struct.unpack("!1B", data)
else:
image_metadata["background"] = struct.unpack("!3H", data)
elif tag == asbytes('tRNS'):
if greyscale:
image_metadata["transparent"] = struct.unpack("!1H", data)
elif has_palette:
# may have several transparent colors
image_metadata["transparent"] = array('B', data)
else:
image_metadata["transparent"] = struct.unpack("!3H", data)
elif tag == asbytes('gAMA'):
image_metadata["gamma"] = (
struct.unpack("!L", data)[0]) / 100000.0
elif tag == asbytes('PLTE'): # http://www.w3.org/TR/PNG/#11PLTE
if not len(data) or len(data) % 3 != 0 or len(data) > 3*(2**(self.bps*8)):
raise Error("invalid palette size")
image_metadata["palette"] = array('B', data)
elif tag == asbytes('IEND'): # http://www.w3.org/TR/PNG/#11IEND
break
scanlines = array('B', zlib.decompress(asbytes('').join(compressed)))
if interlaced:
pixels = self.deinterlace(scanlines)
else:
pixels = self.read_flat(scanlines)
if has_palette:
if "palette" in image_metadata:
# convert the indexed data to RGB, or RGBA if transparent
rgb_pixels = array('B')
for pixel in pixels:
pal_index = pixel*3
rgb_pixels.extend(image_metadata["palette"][pal_index:pal_index+3])
# if there are transparent colors, use RGBA
if "transparent" in image_metadata:
if pixel in image_metadata["transparent"]:
rgb_pixels.append(0)
else:
rgb_pixels.append(255)
pixels = rgb_pixels
self.planes = 3
if "transparent" in image_metadata:
self.planes += 1
has_alpha = True
del image_metadata["transparent"]
if "background" in image_metadata:
pal_index = image_metadata["background"][0]*3
image_metadata["background"] = \
image_metadata["palette"][pal_index:pal_index+3]
else:
raise Error("color_type is indexed but no palette was found")
image_metadata["greyscale"] = greyscale
image_metadata["has_alpha"] = has_alpha
image_metadata["bytes_per_sample"] = bps
image_metadata["interlaced"] = interlaced
return width, height, pixels, image_metadata
def test_suite(options):
"""
Run regression test and write PNG file to stdout.
"""
# Below is a big stack of test image generators
def test_gradient_horizontal_lr(x, y):
return x
def test_gradient_horizontal_rl(x, y):
return 1-x
def test_gradient_vertical_tb(x, y):
return y
def test_gradient_vertical_bt(x, y):
return 1-y
def test_radial_tl(x, y):
return max(1-math.sqrt(x*x+y*y), 0.0)
def test_radial_center(x, y):
return test_radial_tl(x-0.5, y-0.5)
def test_radial_tr(x, y):
return test_radial_tl(1-x, y)
def test_radial_bl(x, y):
return test_radial_tl(x, 1-y)
def test_radial_br(x, y):
return test_radial_tl(1-x, 1-y)
def test_stripe(x, n):
return 1.0*(int(x*n) & 1)
def test_stripe_h_2(x, y):
return test_stripe(x, 2)
def test_stripe_h_4(x, y):
return test_stripe(x, 4)
def test_stripe_h_10(x, y):
return test_stripe(x, 10)
def test_stripe_v_2(x, y):
return test_stripe(y, 2)
def test_stripe_v_4(x, y):
return test_stripe(y, 4)
def test_stripe_v_10(x, y):
return test_stripe(y, 10)
def test_stripe_lr_10(x, y):
return test_stripe(x+y, 10)
def test_stripe_rl_10(x, y):
return test_stripe(x-y, 10)
def test_checker(x, y, n):
return 1.0*((int(x*n) & 1) ^ (int(y*n) & 1))
def test_checker_8(x, y):
return test_checker(x, y, 8)
def test_checker_15(x, y):
return test_checker(x, y, 15)
def test_zero(x, y):
return 0
def test_one(x, y):
return 1
test_patterns = {
"GLR": test_gradient_horizontal_lr,
"GRL": test_gradient_horizontal_rl,
"GTB": test_gradient_vertical_tb,
"GBT": test_gradient_vertical_bt,
"RTL": test_radial_tl,
"RTR": test_radial_tr,
"RBL": test_radial_bl,
"RBR": test_radial_br,
"RCTR": test_radial_center,
"HS2": test_stripe_h_2,
"HS4": test_stripe_h_4,
"HS10": test_stripe_h_10,
"VS2": test_stripe_v_2,
"VS4": test_stripe_v_4,
"VS10": test_stripe_v_10,
"LRS": test_stripe_lr_10,
"RLS": test_stripe_rl_10,
"CK8": test_checker_8,
"CK15": test_checker_15,
"ZERO": test_zero,
"ONE": test_one,
}
def test_pattern(width, height, depth, pattern):
a = array('B')
fw = float(width)
fh = float(height)
pfun = test_patterns[pattern]
if depth == 1:
for y in range(height):
for x in range(width):
a.append(int(pfun(float(x)/fw, float(y)/fh) * 255))
elif depth == 2:
for y in range(height):
for x in range(width):
v = int(pfun(float(x)/fw, float(y)/fh) * 65535)
a.append(v >> 8)
a.append(v & 0xff)
return a
def test_rgba(size=256, depth=1,
red="GTB", green="GLR", blue="RTL", alpha=None):
r = test_pattern(size, size, depth, red)
g = test_pattern(size, size, depth, green)
b = test_pattern(size, size, depth, blue)
if alpha:
a = test_pattern(size, size, depth, alpha)
i = interleave_planes(r, g, depth, depth)
i = interleave_planes(i, b, 2 * depth, depth)
if alpha:
i = interleave_planes(i, a, 3 * depth, depth)
return i
# The body of test_suite()
size = 256
if options.test_size:
size = options.test_size
depth = 1
if options.test_deep:
depth = 2
kwargs = {}
if options.test_red:
kwargs["red"] = options.test_red
if options.test_green:
kwargs["green"] = options.test_green
if options.test_blue:
kwargs["blue"] = options.test_blue
if options.test_alpha:
kwargs["alpha"] = options.test_alpha
pixels = test_rgba(size, depth, **kwargs)
writer = Writer(size, size,
bytes_per_sample=depth,
transparent=options.transparent,
background=options.background,
gamma=options.gamma,
has_alpha=options.test_alpha,
compression=options.compression,
interlaced=options.interlace)
writer.write_array(sys.stdout, pixels)
def read_pnm_header(infile, supported='P6'):
"""
Read a PNM header, return width and height of the image in pixels.
"""
header = []
while len(header) < 4:
line = infile.readline()
sharp = line.find('#')
if sharp > -1:
line = line[:sharp]
header.extend(line.split())
if len(header) == 3 and header[0] == 'P4':
break # PBM doesn't have maxval
if header[0] not in supported:
raise NotImplementedError('file format %s not supported' % header[0])
if header[0] != 'P4' and header[3] != '255':
raise NotImplementedError('maxval %s not supported' % header[3])
return int(header[1]), int(header[2])
def color_triple(color):
"""
Convert a command line color value to a RGB triple of integers.
FIXME: Somewhere we need support for greyscale backgrounds etc.
"""
if color.startswith('#') and len(color) == 4:
return (int(color[1], 16),
int(color[2], 16),
int(color[3], 16))
if color.startswith('#') and len(color) == 7:
return (int(color[1:3], 16),
int(color[3:5], 16),
int(color[5:7], 16))
elif color.startswith('#') and len(color) == 13:
return (int(color[1:5], 16),
int(color[5:9], 16),
int(color[9:13], 16))
def _main():
"""
Run the PNG encoder with options from the command line.
"""
# Parse command line arguments
from optparse import OptionParser
version = '%prog ' + __revision__.strip('$').replace('Rev: ', 'r')
parser = OptionParser(version=version)
parser.set_usage("%prog [options] [pnmfile]")
parser.add_option("-i", "--interlace",
default=False, action="store_true",
help="create an interlaced PNG file (Adam7)")
parser.add_option("-t", "--transparent",
action="store", type="string", metavar="color",
help="mark the specified color as transparent")
parser.add_option("-b", "--background",
action="store", type="string", metavar="color",
help="save the specified background color")
parser.add_option("-a", "--alpha",
action="store", type="string", metavar="pgmfile",
help="alpha channel transparency (RGBA)")
parser.add_option("-g", "--gamma",
action="store", type="float", metavar="value",
help="save the specified gamma value")
parser.add_option("-c", "--compression",
action="store", type="int", metavar="level",
help="zlib compression level (0-9)")
parser.add_option("-T", "--test",
default=False, action="store_true",
help="create a test image")
parser.add_option("-R", "--test-red",
action="store", type="string", metavar="pattern",
help="test pattern for the red image layer")
parser.add_option("-G", "--test-green",
action="store", type="string", metavar="pattern",
help="test pattern for the green image layer")
parser.add_option("-B", "--test-blue",
action="store", type="string", metavar="pattern",
help="test pattern for the blue image layer")
parser.add_option("-A", "--test-alpha",
action="store", type="string", metavar="pattern",
help="test pattern for the alpha image layer")
parser.add_option("-D", "--test-deep",
default=False, action="store_true",
help="use test patterns with 16 bits per layer")
parser.add_option("-S", "--test-size",
action="store", type="int", metavar="size",
help="width and height of the test image")
(options, args) = parser.parse_args()
# Convert options
if options.transparent is not None:
options.transparent = color_triple(options.transparent)
if options.background is not None:
options.background = color_triple(options.background)
# Run regression tests
if options.test:
return test_suite(options)
# Prepare input and output files
if len(args) == 0:
ppmfilename = '-'
ppmfile = sys.stdin
elif len(args) == 1:
ppmfilename = args[0]
ppmfile = open(ppmfilename, 'rb')
else:
parser.error("more than one input file")
outfile = sys.stdout
# Encode PNM to PNG
width, height = read_pnm_header(ppmfile)
writer = Writer(width, height,
transparent=options.transparent,
background=options.background,
has_alpha=options.alpha is not None,
gamma=options.gamma,
compression=options.compression)
if options.alpha is not None:
pgmfile = open(options.alpha, 'rb')
awidth, aheight = read_pnm_header(pgmfile, 'P5')
if (awidth, aheight) != (width, height):
raise ValueError("alpha channel image size mismatch" +
" (%s has %sx%s but %s has %sx%s)"
% (ppmfilename, width, height,
options.alpha, awidth, aheight))
writer.convert_ppm_and_pgm(ppmfile, pgmfile, outfile,
interlace=options.interlace)
else:
writer.convert_ppm(ppmfile, outfile,
interlace=options.interlace)
if __name__ == '__main__':
_main()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Decoder for BMP files.
Currently supports version 3 and 4 bitmaps with BI_RGB and BI_BITFIELDS
encoding. Alpha channel is supported for 32-bit BI_RGB only.
'''
# Official docs are at
# http://msdn2.microsoft.com/en-us/library/ms532311.aspx
#
# But some details including alignment and bit/byte order are omitted; see
# http://www.fileformat.info/format/bmp/egff.htm
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
from pyglet.image import ImageData
from pyglet.image.codecs import ImageDecoder, ImageDecodeException
BYTE = ctypes.c_ubyte
WORD = ctypes.c_uint16
DWORD = ctypes.c_uint32
LONG = ctypes.c_int32
FXPT2DOT30 = ctypes.c_uint32
BI_RGB = 0
BI_RLE8 = 1
BI_RLE4 = 2
BI_BITFIELDS = 3
class BITMAPFILEHEADER(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('bfType', WORD),
('bfSize', DWORD),
('bfReserved1', WORD),
('bfReserved2', WORD),
('bfOffBits', DWORD)
]
class BITMAPINFOHEADER(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('biSize', DWORD),
('biWidth', LONG),
('biHeight', LONG),
('biPlanes', WORD),
('biBitCount', WORD),
('biCompression', DWORD),
('biSizeImage', DWORD),
('biXPelsPerMeter', LONG),
('biYPelsPerMeter', LONG),
('biClrUsed', DWORD),
('biClrImportant', DWORD)
]
CIEXYZTRIPLE = FXPT2DOT30 * 9
class BITMAPV4HEADER(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('biSize', DWORD),
('biWidth', LONG),
('biHeight', LONG),
('biPlanes', WORD),
('biBitCount', WORD),
('biCompression', DWORD),
('biSizeImage', DWORD),
('biXPelsPerMeter', LONG),
('biYPelsPerMeter', LONG),
('biClrUsed', DWORD),
('biClrImportant', DWORD),
('bV4RedMask', DWORD),
('bV4GreenMask', DWORD),
('bV4BlueMask', DWORD),
('bV4AlphaMask', DWORD),
('bV4CSType', DWORD),
('bV4Endpoints', CIEXYZTRIPLE),
('bV4GammaRed', DWORD),
('bV4GammaGreen', DWORD),
('bV4GammaBlue', DWORD),
]
class RGBFields(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('red', DWORD),
('green', DWORD),
('blue', DWORD),
]
class RGBQUAD(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('rgbBlue', BYTE),
('rgbGreen', BYTE),
('rgbRed', BYTE),
('rgbReserved', BYTE)
]
def __repr__(self):
return '<%d, %d, %d>' % (self.rgbRed, self.rgbGreen, self.rgbBlue)
def ptr_add(ptr, offset):
address = ctypes.addressof(ptr.contents) + offset
return ctypes.pointer(type(ptr.contents).from_address(address))
def to_ctypes(buffer, offset, type):
if offset + ctypes.sizeof(type) > len(buffer):
raise ImageDecodeException('BMP file is truncated')
ptr = ptr_add(ctypes.pointer(buffer), offset)
return ctypes.cast(ptr, ctypes.POINTER(type)).contents
class BMPImageDecoder(ImageDecoder):
def get_file_extensions(self):
return ['.bmp']
def decode(self, file, filename):
if not file:
file = open(filename, 'rb')
bytes = file.read()
buffer = ctypes.c_buffer(bytes)
if bytes[:2] != b'BM':
raise ImageDecodeException(
'Not a Windows bitmap file: %r' % (filename or file))
file_header = to_ctypes(buffer, 0, BITMAPFILEHEADER)
bits_offset = file_header.bfOffBits
info_header_offset = ctypes.sizeof(BITMAPFILEHEADER)
info_header = to_ctypes(buffer, info_header_offset, BITMAPINFOHEADER)
palette_offset = info_header_offset + info_header.biSize
if info_header.biSize < ctypes.sizeof(BITMAPINFOHEADER):
raise ImageDecodeException(
'Unsupported BMP type: %r' % (filename or file))
width = info_header.biWidth
height = info_header.biHeight
if width <= 0 or info_header.biPlanes != 1:
raise ImageDecodeException(
'BMP file has corrupt parameters: %r' % (filename or file))
pitch_sign = height < 0 and -1 or 1
height = abs(height)
compression = info_header.biCompression
if compression not in (BI_RGB, BI_BITFIELDS):
raise ImageDecodeException(
'Unsupported compression: %r' % (filename or file))
clr_used = 0
bitcount = info_header.biBitCount
if bitcount == 1:
pitch = (width + 7) // 8
bits_type = ctypes.c_ubyte
decoder = decode_1bit
elif bitcount == 4:
pitch = (width + 1) // 2
bits_type = ctypes.c_ubyte
decoder = decode_4bit
elif bitcount == 8:
bits_type = ctypes.c_ubyte
pitch = width
decoder = decode_8bit
elif bitcount == 16:
pitch = width * 2
bits_type = ctypes.c_uint16
decoder = decode_bitfields
elif bitcount == 24:
pitch = width * 3
bits_type = ctypes.c_ubyte
decoder = decode_24bit
elif bitcount == 32:
pitch = width * 4
if compression == BI_RGB:
decoder = decode_32bit_rgb
bits_type = ctypes.c_ubyte
elif compression == BI_BITFIELDS:
decoder = decode_bitfields
bits_type = ctypes.c_uint32
else:
raise ImageDecodeException(
'Unsupported compression: %r' % (filename or file))
else:
raise ImageDecodeException(
'Unsupported bit count %d: %r' % (bitcount, filename or file))
pitch = (pitch + 3) & ~3
packed_width = pitch // ctypes.sizeof(bits_type)
if bitcount < 16 and compression == BI_RGB:
clr_used = info_header.biClrUsed or (1 << bitcount)
palette = to_ctypes(buffer, palette_offset, RGBQUAD * clr_used)
bits = to_ctypes(buffer, bits_offset,
bits_type * packed_width * height)
return decoder(bits, palette, width, height, pitch, pitch_sign)
elif bitcount >= 16 and compression == BI_RGB:
bits = to_ctypes(buffer, bits_offset,
bits_type * (packed_width * height))
return decoder(bits, None, width, height, pitch, pitch_sign)
elif compression == BI_BITFIELDS:
if info_header.biSize >= ctypes.sizeof(BITMAPV4HEADER):
info_header = to_ctypes(buffer, info_header_offset,
BITMAPV4HEADER)
r_mask = info_header.bV4RedMask
g_mask = info_header.bV4GreenMask
b_mask = info_header.bV4BlueMask
else:
fields_offset = info_header_offset + \
ctypes.sizeof(BITMAPINFOHEADER)
fields = to_ctypes(buffer, fields_offset, RGBFields)
r_mask = fields.red
g_mask = fields.green
b_mask = fields.blue
class _BitsArray(ctypes.LittleEndianStructure):
_pack_ = 1
_fields_ = [
('data', bits_type * packed_width * height),
]
bits = to_ctypes(buffer, bits_offset, _BitsArray).data
return decoder(bits, r_mask, g_mask, b_mask,
width, height, pitch, pitch_sign)
def decode_1bit(bits, palette, width, height, pitch, pitch_sign):
rgb_pitch = (((pitch << 3) + 7) & ~0x7) * 3
buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
i = 0
for row in bits:
for packed in row:
for _ in range(8):
rgb = palette[(packed & 0x80) >> 7]
buffer[i] = rgb.rgbRed
buffer[i + 1] = rgb.rgbGreen
buffer[i + 2] = rgb.rgbBlue
i += 3
packed <<= 1
return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
def decode_4bit(bits, palette, width, height, pitch, pitch_sign):
rgb_pitch = (((pitch << 1) + 1) & ~0x1) * 3
buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
i = 0
for row in bits:
for packed in row:
for index in ((packed & 0xf0) >> 4, packed & 0xf):
rgb = palette[index]
buffer[i] = rgb.rgbRed
buffer[i + 1] = rgb.rgbGreen
buffer[i + 2] = rgb.rgbBlue
i += 3
return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
def decode_8bit(bits, palette, width, height, pitch, pitch_sign):
rgb_pitch = pitch * 3
buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
i = 0
for row in bits:
for index in row:
rgb = palette[index]
buffer[i] = rgb.rgbRed
buffer[i + 1] = rgb.rgbGreen
buffer[i + 2] = rgb.rgbBlue
i += 3
return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
def decode_24bit(bits, palette, width, height, pitch, pitch_sign):
buffer = (ctypes.c_ubyte * (height * pitch))()
ctypes.memmove(buffer, bits, len(buffer))
return ImageData(width, height, 'BGR', buffer, pitch_sign * pitch)
def decode_32bit_rgb(bits, palette, width, height, pitch, pitch_sign):
buffer = (ctypes.c_ubyte * (height * pitch))()
ctypes.memmove(buffer, bits, len(buffer))
return ImageData(width, height, 'BGRA', buffer, pitch_sign * pitch)
def get_shift(mask):
if not mask:
return 0
# Shift down
shift = 0
while not (1 << shift) & mask:
shift += 1
# Shift up
shift_up = 0
while (mask >> shift) >> shift_up:
shift_up += 1
s = shift - (8 - shift_up)
if s < 0:
return 0, -s
else:
return s, 0
def decode_bitfields(bits, r_mask, g_mask, b_mask,
width, height, pitch, pitch_sign):
r_shift1, r_shift2 = get_shift(r_mask)
g_shift1, g_shift2 = get_shift(g_mask)
b_shift1, b_shift2 = get_shift(b_mask)
rgb_pitch = 3 * len(bits[0])
buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
i = 0
for row in bits:
for packed in row:
buffer[i] = (packed & r_mask) >> r_shift1 << r_shift2
buffer[i+1] = (packed & g_mask) >> g_shift1 << g_shift2
buffer[i+2] = (packed & b_mask) >> b_shift1 << b_shift2
i += 3
return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
def get_decoders():
return [BMPImageDecoder()]
def get_encoders():
return []
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Image load, capture and high-level texture functions.
Only basic functionality is described here; for full reference see the
accompanying documentation.
To load an image::
from pyglet import image
pic = image.load('picture.png')
The supported image file types include PNG, BMP, GIF, JPG, and many more,
somewhat depending on the operating system. To load an image from a file-like
object instead of a filename::
pic = image.load('hint.jpg', file=fileobj)
The hint helps the module locate an appropriate decoder to use based on the
file extension. It is optional.
Once loaded, images can be used directly by most other modules of pyglet. All
images have a width and height you can access::
width, height = pic.width, pic.height
You can extract a region of an image (this keeps the original image intact;
the memory is shared efficiently)::
subimage = pic.get_region(x, y, width, height)
Remember that y-coordinates are always increasing upwards.
Drawing images
--------------
To draw an image at some point on the screen::
pic.blit(x, y, z)
This assumes an appropriate view transform and projection have been applied.
Some images have an intrinsic "anchor point": this is the point which will be
aligned to the ``x`` and ``y`` coordinates when the image is drawn. By
default the anchor point is the lower-left corner of the image. You can use
the anchor point to center an image at a given point, for example::
pic.anchor_x = pic.width // 2
pic.anchor_y = pic.height // 2
pic.blit(x, y, z)
Texture access
--------------
If you are using OpenGL directly, you can access the image as a texture::
texture = pic.get_texture()
(This is the most efficient way to obtain a texture; some images are
immediately loaded as textures, whereas others go through an intermediate
form). To use a texture with pyglet.gl::
from pyglet.gl import *
glEnable(texture.target) # typically target is GL_TEXTURE_2D
glBindTexture(texture.target, texture.id)
# ... draw with the texture
Pixel access
------------
To access raw pixel data of an image::
rawimage = pic.get_image_data()
(If the image has just been loaded this will be a very quick operation;
however if the image is a texture a relatively expensive readback operation
will occur). The pixels can be accessed as a string::
format = 'RGBA'
pitch = rawimage.width * len(format)
pixels = rawimage.get_data(format, pitch)
"format" strings consist of characters that give the byte order of each color
component. For example, if rawimage.format is 'RGBA', there are four color
components: red, green, blue and alpha, in that order. Other common format
strings are 'RGB', 'LA' (luminance, alpha) and 'I' (intensity).
The "pitch" of an image is the number of bytes in a row (this may validly be
more than the number required to make up the width of the image, it is common
to see this for word alignment). If "pitch" is negative the rows of the image
are ordered from top to bottom, otherwise they are ordered from bottom to top.
Retrieving data with the format and pitch given in `ImageData.format` and
`ImageData.pitch` avoids the need for data conversion (assuming you can make
use of the data in this arbitrary format).
'''
from __future__ import division
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import sys
import re
import warnings
import weakref
from ctypes import *
from math import ceil
from pyglet import gl
from pyglet.gl import *
from pyglet.gl import gl_info
from pyglet import graphics
from pyglet.window import *
from pyglet.image import atlas
from pyglet.compat import asbytes, bytes_type, BytesIO
class ImageException(Exception):
pass
def load(filename, file=None, decoder=None):
'''Load an image from a file.
:note: You can make no assumptions about the return type; usually it will
be ImageData or CompressedImageData, but decoders are free to return
any subclass of AbstractImage.
:Parameters:
`filename` : str
Used to guess the image format, and to load the file if `file` is
unspecified.
`file` : file-like object or None
Source of image data in any supported format.
`decoder` : ImageDecoder or None
If unspecified, all decoders that are registered for the filename
extension are tried. If none succeed, the exception from the
first decoder is raised.
:rtype: AbstractImage
'''
if not file:
file = open(filename, 'rb')
opened_file = file
else:
opened_file = None
if not hasattr(file, 'seek'):
file = BytesIO(file.read())
try:
if decoder:
return decoder.decode(file, filename)
else:
first_exception = None
for decoder in codecs.get_decoders(filename):
try:
image = decoder.decode(file, filename)
return image
except codecs.ImageDecodeException, e:
if (not first_exception or
first_exception.exception_priority < e.exception_priority):
first_exception = e
file.seek(0)
if not first_exception:
raise codecs.ImageDecodeException('No image decoders are available')
raise first_exception
finally:
if opened_file:
opened_file.close()
def create(width, height, pattern=None):
'''Create an image optionally filled with the given pattern.
:note: You can make no assumptions about the return type; usually it will
be ImageData or CompressedImageData, but patterns are free to return
any subclass of AbstractImage.
:Parameters:
`width` : int
Width of image to create
`height` : int
Height of image to create
`pattern` : ImagePattern or None
Pattern to fill image with. If unspecified, the image will
initially be transparent.
:rtype: AbstractImage
'''
if not pattern:
pattern = SolidColorImagePattern()
return pattern.create_image(width, height)
def color_as_bytes(color):
if sys.version.startswith('2'):
return '%c%c%c%c' % color
else:
if len(color) != 4:
raise TypeError("color is expected to have 4 components")
return bytes(color)
class ImagePattern(object):
'''Abstract image creation class.'''
def create_image(self, width, height):
'''Create an image of the given size.
:Parameters:
`width` : int
Width of image to create
`height` : int
Height of image to create
:rtype: AbstractImage
'''
raise NotImplementedError('abstract')
class SolidColorImagePattern(ImagePattern):
'''Creates an image filled with a solid color.'''
def __init__(self, color=(0, 0, 0, 0)):
'''Create a solid image pattern with the given color.
:Parameters:
`color` : (int, int, int, int)
4-tuple of ints in range [0,255] giving RGBA components of
color to fill with.
'''
self.color = color_as_bytes(color)
def create_image(self, width, height):
data = self.color * width * height
return ImageData(width, height, 'RGBA', data)
class CheckerImagePattern(ImagePattern):
'''Create an image with a tileable checker image.
'''
def __init__(self, color1=(150,150,150,255), color2=(200,200,200,255)):
'''Initialise with the given colors.
:Parameters:
`color1` : (int, int, int, int)
4-tuple of ints in range [0,255] giving RGBA components of
color to fill with. This color appears in the top-left and
bottom-right corners of the image.
`color2` : (int, int, int, int)
4-tuple of ints in range [0,255] giving RGBA components of
color to fill with. This color appears in the top-right and
bottom-left corners of the image.
'''
self.color1 = color_as_bytes(color1)
self.color2 = color_as_bytes(color2)
def create_image(self, width, height):
hw = width // 2
hh = height // 2
row1 = self.color1 * hw + self.color2 * hw
row2 = self.color2 * hw + self.color1 * hw
data = row1 * hh + row2 * hh
return ImageData(width, height, 'RGBA', data)
class AbstractImage(object):
'''Abstract class representing an image.
:Ivariables:
`width` : int
Width of image
`height` : int
Height of image
`anchor_x` : int
X coordinate of anchor, relative to left edge of image data
`anchor_y` : int
Y coordinate of anchor, relative to bottom edge of image data
'''
anchor_x = 0
anchor_y = 0
_is_rectangle = False
def __init__(self, width, height):
self.width = width
self.height = height
def __repr__(self):
return '<%s %dx%d>' % (self.__class__.__name__, self.width, self.height)
def get_image_data(self):
'''Get an ImageData view of this image.
Changes to the returned instance may or may not be reflected in this
image.
:rtype: `ImageData`
:since: pyglet 1.1
'''
raise ImageException('Cannot retrieve image data for %r' % self)
image_data = property(lambda self: self.get_image_data(),
doc='''An `ImageData` view of this image.
Changes to the returned instance may or may not be reflected in this
image. Read-only.
:deprecated: Use `get_image_data`.
:type: `ImageData`
''')
def get_texture(self, rectangle=False, force_rectangle=False):
'''A `Texture` view of this image.
By default, textures are created with dimensions that are powers of
two. Smaller images will return a `TextureRegion` that covers just
the image portion of the larger texture. This restriction is required
on older video cards, and for compressed textures, or where texture
repeat modes will be used, or where mipmapping is desired.
If the `rectangle` parameter is ``True``, this restriction is ignored
and a texture the size of the image may be created if the driver
supports the ``GL_ARB_texture_rectangle`` or
``GL_NV_texture_rectangle`` extensions. If the extensions are not
present, the image already is a texture, or the image has power 2
dimensions, the `rectangle` parameter is ignored.
Examine `Texture.target` to determine if the returned texture is a
rectangle (``GL_TEXTURE_RECTANGLE_ARB`` or
``GL_TEXTURE_RECTANGLE_NV``) or not (``GL_TEXTURE_2D``).
If the `force_rectangle` parameter is ``True``, one of these
extensions must be present, and the returned texture always
has target ``GL_TEXTURE_RECTANGLE_ARB`` or ``GL_TEXTURE_RECTANGLE_NV``.
Changes to the returned instance may or may not be reflected in this
image.
:Parameters:
`rectangle` : bool
True if the texture can be created as a rectangle.
`force_rectangle` : bool
True if the texture must be created as a rectangle.
**Since:** pyglet 1.1.4.
:rtype: `Texture`
:since: pyglet 1.1
'''
raise ImageException('Cannot retrieve texture for %r' % self)
texture = property(lambda self: self.get_texture(),
doc='''Get a `Texture` view of this image.
Changes to the returned instance may or may not be reflected in this
image.
:deprecated: Use `get_texture`.
:type: `Texture`
''')
def get_mipmapped_texture(self):
'''Retrieve a `Texture` instance with all mipmap levels filled in.
Requires that image dimensions be powers of 2.
:rtype: `Texture`
:since: pyglet 1.1
'''
raise ImageException('Cannot retrieve mipmapped texture for %r' % self)
mipmapped_texture = property(lambda self: self.get_mipmapped_texture(),
doc='''A Texture view of this image.
The returned Texture will have mipmaps filled in for all levels.
Requires that image dimensions be powers of 2. Read-only.
:deprecated: Use `get_mipmapped_texture`.
:type: `Texture`
''')
def get_region(self, x, y, width, height):
'''Retrieve a rectangular region of this image.
:Parameters:
`x` : int
Left edge of region.
`y` : int
Bottom edge of region.
`width` : int
Width of region.
`height` : int
Height of region.
:rtype: AbstractImage
'''
raise ImageException('Cannot get region for %r' % self)
def save(self, filename=None, file=None, encoder=None):
'''Save this image to a file.
:Parameters:
`filename` : str
Used to set the image file format, and to open the output file
if `file` is unspecified.
`file` : file-like object or None
File to write image data to.
`encoder` : ImageEncoder or None
If unspecified, all encoders matching the filename extension
are tried. If all fail, the exception from the first one
attempted is raised.
'''
if not file:
file = open(filename, 'wb')
if encoder:
encoder.encode(self, file, filename)
else:
first_exception = None
for encoder in codecs.get_encoders(filename):
try:
encoder.encode(self, file, filename)
return
except codecs.ImageEncodeException, e:
first_exception = first_exception or e
file.seek(0)
if not first_exception:
raise codecs.ImageEncodeException(
'No image encoders are available')
raise first_exception
def blit(self, x, y, z=0):
'''Draw this image to the active framebuffers.
The image will be drawn with the lower-left corner at
(``x -`` `anchor_x`, ``y -`` `anchor_y`, ``z``).
'''
raise ImageException('Cannot blit %r.' % self)
def blit_into(self, source, x, y, z):
'''Draw `source` on this image.
`source` will be copied into this image such that its anchor point
is aligned with the `x` and `y` parameters. If this image is a 3D
texture, the `z` coordinate gives the image slice to copy into.
Note that if `source` is larger than this image (or the positioning
would cause the copy to go out of bounds) then you must pass a
region of `source` to this method, typically using get_region().
'''
raise ImageException('Cannot blit images onto %r.' % self)
def blit_to_texture(self, target, level, x, y, z=0):
'''Draw this image on the currently bound texture at `target`.
This image is copied into the texture such that this image's anchor
point is aligned with the given `x` and `y` coordinates of the
destination texture. If the currently bound texture is a 3D texture,
the `z` coordinate gives the image slice to blit into.
'''
raise ImageException('Cannot blit %r to a texture.' % self)
class AbstractImageSequence(object):
'''Abstract sequence of images.
The sequence is useful for storing image animations or slices of a volume.
For efficient access, use the `texture_sequence` member. The class
also implements the sequence interface (`__len__`, `__getitem__`,
`__setitem__`).
'''
def get_texture_sequence(self):
'''Get a TextureSequence.
:rtype: `TextureSequence`
:since: pyglet 1.1
'''
raise NotImplementedError('abstract')
texture_sequence = property(lambda self: self.get_texture_sequence(),
doc='''Access this image sequence as a texture sequence.
:deprecated: Use `get_texture_sequence`
:type: `TextureSequence`
''')
def get_animation(self, period, loop=True):
'''Create an animation over this image sequence for the given constant
framerate.
:Parameters
`period` : float
Number of seconds to display each frame.
`loop` : bool
If True, the animation will loop continuously.
:rtype: `Animation`
:since: pyglet 1.1
'''
return Animation.from_image_sequence(self, period, loop)
def __getitem__(self, slice):
'''Retrieve a (list of) image.
:rtype: AbstractImage
'''
raise NotImplementedError('abstract')
def __setitem__(self, slice, image):
'''Replace one or more images in the sequence.
:Parameters:
`image` : `AbstractImage`
The replacement image. The actual instance may not be used,
depending on this implementation.
'''
raise NotImplementedError('abstract')
def __len__(self):
raise NotImplementedError('abstract')
def __iter__(self):
'''Iterate over the images in sequence.
:rtype: Iterator
:since: pyglet 1.1
'''
raise NotImplementedError('abstract')
class TextureSequence(AbstractImageSequence):
'''Interface for a sequence of textures.
Typical implementations store multiple `TextureRegion` s within one
`Texture` so as to minimise state changes.
'''
def get_texture_sequence(self):
return self
class UniformTextureSequence(TextureSequence):
'''Interface for a sequence of textures, each with the same dimensions.
:Ivariables:
`item_width` : int
Width of each texture in the sequence.
`item_height` : int
Height of each texture in the sequence.
'''
def _get_item_width(self):
raise NotImplementedError('abstract')
item_width = property(_get_item_width)
def _get_item_height(self):
raise NotImplementedError('abstract')
item_height = property(_get_item_height)
class ImageData(AbstractImage):
'''An image represented as a string of unsigned bytes.
:Ivariables:
`data` : str
Pixel data, encoded according to `format` and `pitch`.
`format` : str
The format string to use when reading or writing `data`.
`pitch` : int
Number of bytes per row. Negative values indicate a top-to-bottom
arrangement.
Setting the `format` and `pitch` instance variables and reading `data` is
deprecated; use `get_data` and `set_data` in new applications. (Reading
`format` and `pitch` to obtain the current encoding is not deprecated).
'''
_swap1_pattern = re.compile(asbytes('(.)'), re.DOTALL)
_swap2_pattern = re.compile(asbytes('(.)(.)'), re.DOTALL)
_swap3_pattern = re.compile(asbytes('(.)(.)(.)'), re.DOTALL)
_swap4_pattern = re.compile(asbytes('(.)(.)(.)(.)'), re.DOTALL)
_current_texture = None
_current_mipmap_texture = None
def __init__(self, width, height, format, data, pitch=None):
'''Initialise image data.
:Parameters:
`width` : int
Width of image data
`height` : int
Height of image data
`format` : str
A valid format string, such as 'RGB', 'RGBA', 'ARGB', etc.
`data` : sequence
String or array/list of bytes giving the decoded data.
`pitch` : int or None
If specified, the number of bytes per row. Negative values
indicate a top-to-bottom arrangement. Defaults to
``width * len(format)``.
'''
super(ImageData, self).__init__(width, height)
self._current_format = self._desired_format = format.upper()
self._current_data = data
if not pitch:
pitch = width * len(format)
self._current_pitch = self.pitch = pitch
self.mipmap_images = []
def __getstate__(self):
return {
'width': self.width,
'height': self.height,
'_current_data':
self.get_data(self._current_format, self._current_pitch),
'_current_format': self._current_format,
'_desired_format': self._desired_format,
'_current_pitch': self._current_pitch,
'pitch': self.pitch,
'mipmap_images': self.mipmap_images
}
def get_image_data(self):
return self
def _set_format(self, format):
self._desired_format = format.upper()
self._current_texture = None
format = property(lambda self: self._desired_format, _set_format,
doc='''Format string of the data. Read-write.
:type: str
''')
def _get_data(self):
if self._current_pitch != self.pitch or \
self._current_format != self.format:
self._current_data = self._convert(self.format, self.pitch)
self._current_format = self.format
self._current_pitch = self.pitch
self._ensure_string_data()
return self._current_data
def _set_data(self, data):
self._current_data = data
self._current_format = self.format
self._current_pitch = self.pitch
self._current_texture = None
self._current_mipmapped_texture = None
data = property(_get_data, _set_data,
doc='''The byte data of the image. Read-write.
:deprecated: Use `get_data` and `set_data`.
:type: sequence of bytes, or str
''')
def get_data(self, format, pitch):
'''Get the byte data of the image.
:Parameters:
`format` : str
Format string of the return data.
`pitch` : int
Number of bytes per row. Negative values indicate a
top-to-bottom arrangement.
:since: pyglet 1.1
:rtype: sequence of bytes, or str
'''
if format == self._current_format and pitch == self._current_pitch:
return self._current_data
return self._convert(format, pitch)
def set_data(self, format, pitch, data):
'''Set the byte data of the image.
:Parameters:
`format` : str
Format string of the return data.
`pitch` : int
Number of bytes per row. Negative values indicate a
top-to-bottom arrangement.
`data` : str or sequence of bytes
Image data.
:since: pyglet 1.1
'''
self._current_format = format
self._current_pitch = pitch
self._current_data = data
self._current_texture = None
self._current_mipmapped_texture = None
def set_mipmap_image(self, level, image):
'''Set a mipmap image for a particular level.
The mipmap image will be applied to textures obtained via
`get_mipmapped_texture`.
:Parameters:
`level` : int
Mipmap level to set image at, must be >= 1.
`image` : AbstractImage
Image to set. Must have correct dimensions for that mipmap
level (i.e., width >> level, height >> level)
'''
if level == 0:
raise ImageException(
'Cannot set mipmap image at level 0 (it is this image)')
if not _is_pow2(self.width) or not _is_pow2(self.height):
raise ImageException(
'Image dimensions must be powers of 2 to use mipmaps.')
# Check dimensions of mipmap
width, height = self.width, self.height
for i in range(level):
width >>= 1
height >>= 1
if width != image.width or height != image.height:
raise ImageException(
'Mipmap image has wrong dimensions for level %d' % level)
# Extend mipmap_images list to required level
self.mipmap_images += [None] * (level - len(self.mipmap_images))
self.mipmap_images[level - 1] = image
def create_texture(self, cls, rectangle=False, force_rectangle=False):
'''Create a texture containing this image.
If the image's dimensions are not powers of 2, a TextureRegion of
a larger Texture will be returned that matches the dimensions of this
image.
:Parameters:
`cls` : class (subclass of Texture)
Class to construct.
`rectangle` : bool
``True`` if a rectangle can be created; see
`AbstractImage.get_texture`.
**Since:** pyglet 1.1
`force_rectangle` : bool
``True`` if a rectangle must be created; see
`AbstractImage.get_texture`.
**Since:** pyglet 1.1.4
:rtype: cls or cls.region_class
'''
internalformat = self._get_internalformat(self.format)
texture = cls.create(self.width, self.height, internalformat,
rectangle, force_rectangle)
if self.anchor_x or self.anchor_y:
texture.anchor_x = self.anchor_x
texture.anchor_y = self.anchor_y
self.blit_to_texture(texture.target, texture.level,
self.anchor_x, self.anchor_y, 0, None)
return texture
def get_texture(self, rectangle=False, force_rectangle=False):
if (not self._current_texture or
(not self._current_texture._is_rectangle and force_rectangle)):
self._current_texture = self.create_texture(Texture,
rectangle,
force_rectangle)
return self._current_texture
def get_mipmapped_texture(self):
'''Return a Texture with mipmaps.
If `set_mipmap_image` has been called with at least one image, the set
of images defined will be used. Otherwise, mipmaps will be
automatically generated.
The texture dimensions must be powers of 2 to use mipmaps.
:rtype: `Texture`
:since: pyglet 1.1
'''
if self._current_mipmap_texture:
return self._current_mipmap_texture
if not _is_pow2(self.width) or not _is_pow2(self.height):
raise ImageException(
'Image dimensions must be powers of 2 to use mipmaps.')
texture = Texture.create_for_size(
GL_TEXTURE_2D, self.width, self.height)
if self.anchor_x or self.anchor_y:
texture.anchor_x = self.anchor_x
texture.anchor_y = self.anchor_y
internalformat = self._get_internalformat(self.format)
glBindTexture(texture.target, texture.id)
glTexParameteri(texture.target, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
if self.mipmap_images:
self.blit_to_texture(texture.target, texture.level,
self.anchor_x, self.anchor_y, 0, internalformat)
level = 0
for image in self.mipmap_images:
level += 1
if image:
image.blit_to_texture(texture.target, level,
self.anchor_x, self.anchor_y, 0, internalformat)
# TODO: should set base and max mipmap level if some mipmaps
# are missing.
elif gl_info.have_version(1, 4):
glTexParameteri(texture.target, GL_GENERATE_MIPMAP, GL_TRUE)
self.blit_to_texture(texture.target, texture.level,
self.anchor_x, self.anchor_y, 0, internalformat)
else:
raise NotImplementedError('TODO: gluBuild2DMipmaps')
self._current_mipmap_texture = texture
return texture
def get_region(self, x, y, width, height):
'''Retrieve a rectangular region of this image data.
:Parameters:
`x` : int
Left edge of region.
`y` : int
Bottom edge of region.
`width` : int
Width of region.
`height` : int
Height of region.
:rtype: ImageDataRegion
'''
return ImageDataRegion(x, y, width, height, self)
def blit(self, x, y, z=0, width=None, height=None):
self.get_texture().blit(x, y, z, width, height)
def blit_to_texture(self, target, level, x, y, z, internalformat=None):
'''Draw this image to to the currently bound texture at `target`.
This image's anchor point will be aligned to the given `x` and `y`
coordinates. If the currently bound texture is a 3D texture, the `z`
parameter gives the image slice to blit into.
If `internalformat` is specified, glTexImage is used to initialise
the texture; otherwise, glTexSubImage is used to update a region.
'''
x -= self.anchor_x
y -= self.anchor_y
data_format = self.format
data_pitch = abs(self._current_pitch)
# Determine pixel format from format string
matrix = None
format, type = self._get_gl_format_and_type(data_format)
if format is None:
if (len(data_format) in (3, 4) and
gl_info.have_extension('GL_ARB_imaging')):
# Construct a color matrix to convert to GL_RGBA
def component_column(component):
try:
pos = 'RGBA'.index(component)
return [0] * pos + [1] + [0] * (3 - pos)
except ValueError:
return [0, 0, 0, 0]
# pad to avoid index exceptions
lookup_format = data_format + 'XXX'
matrix = (component_column(lookup_format[0]) +
component_column(lookup_format[1]) +
component_column(lookup_format[2]) +
component_column(lookup_format[3]))
format = {
3: GL_RGB,
4: GL_RGBA}.get(len(data_format))
type = GL_UNSIGNED_BYTE
glMatrixMode(GL_COLOR)
glPushMatrix()
glLoadMatrixf((GLfloat * 16)(*matrix))
else:
# Need to convert data to a standard form
data_format = {
1: 'L',
2: 'LA',
3: 'RGB',
4: 'RGBA'}.get(len(data_format))
format, type = self._get_gl_format_and_type(data_format)
# Workaround: don't use GL_UNPACK_ROW_LENGTH
if gl.current_context._workaround_unpack_row_length:
data_pitch = self.width * len(data_format)
# Get data in required format (hopefully will be the same format it's
# already in, unless that's an obscure format, upside-down or the
# driver is old).
data = self._convert(data_format, data_pitch)
if data_pitch & 0x1:
alignment = 1
elif data_pitch & 0x2:
alignment = 2
else:
alignment = 4
row_length = data_pitch // len(data_format)
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
self._apply_region_unpack()
if target == GL_TEXTURE_3D:
assert not internalformat
glTexSubImage3D(target, level,
x, y, z,
self.width, self.height, 1,
format, type,
data)
elif internalformat:
glTexImage2D(target, level,
internalformat,
self.width, self.height,
0,
format, type,
data)
else:
glTexSubImage2D(target, level,
x, y,
self.width, self.height,
format, type,
data)
glPopClientAttrib()
if matrix:
glPopMatrix()
glMatrixMode(GL_MODELVIEW)
# Flush image upload before data get GC'd.
glFlush()
def _apply_region_unpack(self):
pass
def _convert(self, format, pitch):
'''Return data in the desired format; does not alter this instance's
current format or pitch.
'''
if format == self._current_format and pitch == self._current_pitch:
if type(self._current_data) is str:
return asbytes(self._current_data)
return self._current_data
self._ensure_string_data()
data = self._current_data
current_pitch = self._current_pitch
current_format = self._current_format
sign_pitch = current_pitch // abs(current_pitch)
if format != self._current_format:
# Create replacement string, e.g. r'\4\1\2\3' to convert RGBA to
# ARGB
repl = asbytes('')
for c in format:
try:
idx = current_format.index(c) + 1
except ValueError:
idx = 1
repl += asbytes(r'\%d' % idx)
if len(current_format) == 1:
swap_pattern = self._swap1_pattern
elif len(current_format) == 2:
swap_pattern = self._swap2_pattern
elif len(current_format) == 3:
swap_pattern = self._swap3_pattern
elif len(current_format) == 4:
swap_pattern = self._swap4_pattern
else:
raise ImageException(
'Current image format is wider than 32 bits.')
packed_pitch = self.width * len(current_format)
if abs(self._current_pitch) != packed_pitch:
# Pitch is wider than pixel data, need to go row-by-row.
rows = re.findall(
asbytes('.') * abs(self._current_pitch), data, re.DOTALL)
rows = [swap_pattern.sub(repl, r[:packed_pitch]) for r in rows]
data = asbytes('').join(rows)
else:
# Rows are tightly packed, apply regex over whole image.
data = swap_pattern.sub(repl, data)
# After conversion, rows will always be tightly packed
current_pitch = sign_pitch * (len(format) * self.width)
if pitch != current_pitch:
diff = abs(current_pitch) - abs(pitch)
if diff > 0:
# New pitch is shorter than old pitch, chop bytes off each row
pattern = re.compile(
asbytes('(%s)%s' % ('.' * abs(pitch), '.' * diff)), re.DOTALL)
data = pattern.sub(asbytes(r'\1'), data)
elif diff < 0:
# New pitch is longer than old pitch, add '0' bytes to each row
pattern = re.compile(
asbytes('(%s)' % ('.' * abs(current_pitch))), re.DOTALL)
pad = '.' * -diff
data = pattern.sub(asbytes(r'\1%s' % pad), data)
if current_pitch * pitch < 0:
# Pitch differs in sign, swap row order
rows = re.findall(asbytes('.') * abs(pitch), data, re.DOTALL)
rows.reverse()
data = asbytes('').join(rows)
return asbytes(data)
def _ensure_string_data(self):
if type(self._current_data) is not bytes_type:
buf = create_string_buffer(len(self._current_data))
memmove(buf, self._current_data, len(self._current_data))
self._current_data = buf.raw
def _get_gl_format_and_type(self, format):
if format == 'I':
return GL_LUMINANCE, GL_UNSIGNED_BYTE
elif format == 'L':
return GL_LUMINANCE, GL_UNSIGNED_BYTE
elif format == 'LA':
return GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE
elif format == 'R':
return GL_RED, GL_UNSIGNED_BYTE
elif format == 'G':
return GL_GREEN, GL_UNSIGNED_BYTE
elif format == 'B':
return GL_BLUE, GL_UNSIGNED_BYTE
elif format == 'A':
return GL_ALPHA, GL_UNSIGNED_BYTE
elif format == 'RGB':
return GL_RGB, GL_UNSIGNED_BYTE
elif format == 'RGBA':
return GL_RGBA, GL_UNSIGNED_BYTE
elif (format == 'ARGB' and
gl_info.have_extension('GL_EXT_bgra') and
gl_info.have_extension('GL_APPLE_packed_pixels')):
return GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV
elif (format == 'ABGR' and
gl_info.have_extension('GL_EXT_abgr')):
return GL_ABGR_EXT, GL_UNSIGNED_BYTE
elif (format == 'BGR' and
gl_info.have_extension('GL_EXT_bgra')):
return GL_BGR, GL_UNSIGNED_BYTE
elif (format == 'BGRA' and
gl_info.have_extension('GL_EXT_bgra')):
return GL_BGRA, GL_UNSIGNED_BYTE
return None, None
def _get_internalformat(self, format):
if len(format) == 4:
return GL_RGBA
elif len(format) == 3:
return GL_RGB
elif len(format) == 2:
return GL_LUMINANCE_ALPHA
elif format == 'A':
return GL_ALPHA
elif format == 'L':
return GL_LUMINANCE
elif format == 'I':
return GL_INTENSITY
return GL_RGBA
class ImageDataRegion(ImageData):
def __init__(self, x, y, width, height, image_data):
super(ImageDataRegion, self).__init__(width, height,
image_data._current_format, image_data._current_data,
image_data._current_pitch)
self.x = x
self.y = y
def __getstate__(self):
return {
'width': self.width,
'height': self.height,
'_current_data':
self.get_data(self._current_format, self._current_pitch),
'_current_format': self._current_format,
'_desired_format': self._desired_format,
'_current_pitch': self._current_pitch,
'pitch': self.pitch,
'mipmap_images': self.mipmap_images,
'x': self.x,
'y': self.y
}
def _get_data(self):
# Crop the data first
x1 = len(self._current_format) * self.x
x2 = len(self._current_format) * (self.x + self.width)
self._ensure_string_data()
data = self._convert(self._current_format, abs(self._current_pitch))
rows = re.findall(b'.' * abs(self._current_pitch), data, re.DOTALL)
rows = [row[x1:x2] for row in rows[self.y:self.y+self.height]]
self._current_data = b''.join(rows)
self._current_pitch = self.width * len(self._current_format)
self._current_texture = None
self.x = 0
self.y = 0
return super(ImageDataRegion, self)._get_data()
def _set_data(self, data):
self.x = 0
self.y = 0
super(ImageDataRegion, self)._set_data(data)
data = property(_get_data, _set_data)
def get_data(self, format, pitch):
x1 = len(self._current_format) * self.x
x2 = len(self._current_format) * (self.x + self.width)
self._ensure_string_data()
data = self._convert(self._current_format, abs(self._current_pitch))
rows = re.findall(asbytes('.') * abs(self._current_pitch), data,
re.DOTALL)
rows = [row[x1:x2] for row in rows[self.y:self.y+self.height]]
self._current_data = asbytes('').join(rows)
self._current_pitch = self.width * len(self._current_format)
self._current_texture = None
self.x = 0
self.y = 0
return super(ImageDataRegion, self).get_data(format, pitch)
def _apply_region_unpack(self):
glPixelStorei(GL_UNPACK_SKIP_PIXELS, self.x)
glPixelStorei(GL_UNPACK_SKIP_ROWS, self.y)
def _ensure_string_data(self):
super(ImageDataRegion, self)._ensure_string_data()
def get_region(self, x, y, width, height):
x += self.x
y += self.y
return super(ImageDataRegion, self).get_region(x, y, width, height)
class CompressedImageData(AbstractImage):
'''Image representing some compressed data suitable for direct uploading
to driver.
'''
_current_texture = None
_current_mipmapped_texture = None
def __init__(self, width, height, gl_format, data,
extension=None, decoder=None):
'''Construct a CompressedImageData with the given compressed data.
:Parameters:
`width` : int
Width of image
`height` : int
Height of image
`gl_format` : int
GL constant giving format of compressed data; for example,
``GL_COMPRESSED_RGBA_S3TC_DXT5_EXT``.
`data` : sequence
String or array/list of bytes giving compressed image data.
`extension` : str or None
If specified, gives the name of a GL extension to check for
before creating a texture.
`decoder` : function(data, width, height) -> AbstractImage
A function to decode the compressed data, to be used if the
required extension is not present.
'''
if not _is_pow2(width) or not _is_pow2(height):
raise ImageException('Dimensions of %r must be powers of 2' % self)
super(CompressedImageData, self).__init__(width, height)
self.data = data
self.gl_format = gl_format
self.extension = extension
self.decoder = decoder
self.mipmap_data = []
def set_mipmap_data(self, level, data):
'''Set data for a mipmap level.
Supplied data gives a compressed image for the given mipmap level.
The image must be of the correct dimensions for the level
(i.e., width >> level, height >> level); but this is not checked. If
any mipmap levels are specified, they are used; otherwise, mipmaps for
`mipmapped_texture` are generated automatically.
:Parameters:
`level` : int
Level of mipmap image to set.
`data` : sequence
String or array/list of bytes giving compressed image data.
Data must be in same format as specified in constructor.
'''
# Extend mipmap_data list to required level
self.mipmap_data += [None] * (level - len(self.mipmap_data))
self.mipmap_data[level - 1] = data
def _have_extension(self):
return self.extension is None or gl_info.have_extension(self.extension)
def _verify_driver_supported(self):
'''Assert that the extension required for this image data is
supported.
Raises `ImageException` if not.
'''
if not self._have_extension():
raise ImageException('%s is required to decode %r' % \
(self.extension, self))
def get_texture(self, rectangle=False, force_rectangle=False):
if force_rectangle:
raise ImageException(
'Compressed texture rectangles not supported')
if self._current_texture:
return self._current_texture
texture = Texture.create_for_size(
GL_TEXTURE_2D, self.width, self.height)
if self.anchor_x or self.anchor_y:
texture.anchor_x = self.anchor_x
texture.anchor_y = self.anchor_y
glBindTexture(texture.target, texture.id)
glTexParameteri(texture.target, GL_TEXTURE_MIN_FILTER, texture.min_filter)
glTexParameteri(texture.target, GL_TEXTURE_MAG_FILTER, texture.mag_filter)
if self._have_extension():
glCompressedTexImage2DARB(texture.target, texture.level,
self.gl_format,
self.width, self.height, 0,
len(self.data), self.data)
else:
image = self.decoder(self.data, self.width, self.height)
texture = image.get_texture()
assert texture.width == self.width
assert texture.height == self.height
glFlush()
self._current_texture = texture
return texture
def get_mipmapped_texture(self):
if self._current_mipmap_texture:
return self._current_mipmap_texture
if not self._have_extension():
# TODO mip-mapped software decoded compressed textures. For now,
# just return a non-mipmapped texture.
return self.get_texture()
texture = Texture.create_for_size(
GL_TEXTURE_2D, self.width, self.height)
if self.anchor_x or self.anchor_y:
texture.anchor_x = self.anchor_x
texture.anchor_y = self.anchor_y
glBindTexture(texture.target, texture.id)
glTexParameteri(texture.target, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
if not self.mipmap_data:
if not gl_info.have_version(1, 4):
raise ImageException(
'Require GL 1.4 to generate mipmaps for compressed textures')
glTexParameteri(texture.target, GL_GENERATE_MIPMAP, GL_TRUE)
glCompressedTexImage2DARB(texture.target, texture.level,
self.gl_format,
self.width, self.height, 0,
len(self.data), self.data)
width, height = self.width, self.height
level = 0
for data in self.mipmap_data:
width >>= 1
height >>= 1
level += 1
glCompressedTexImage2DARB(texture.target, level,
self.gl_format,
width, height, 0,
len(data), data)
glFlush()
self._current_mipmap_texture = texture
return texture
def blit_to_texture(self, target, level, x, y, z):
self._verify_driver_supported()
if target == GL_TEXTURE_3D:
glCompressedTexSubImage3DARB(target, level,
x - self.anchor_x, y - self.anchor_y, z,
self.width, self.height, 1,
self.gl_format,
len(self.data), self.data)
else:
glCompressedTexSubImage2DARB(target, level,
x - self.anchor_x, y - self.anchor_y,
self.width, self.height,
self.gl_format,
len(self.data), self.data)
def _nearest_pow2(v):
# From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
# Credit: Sean Anderson
v -= 1
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
return v + 1
def _is_pow2(v):
# http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
return (v & (v - 1)) == 0
class Texture(AbstractImage):
'''An image loaded into video memory that can be efficiently drawn
to the framebuffer.
Typically you will get an instance of Texture by accessing the `texture`
member of any other AbstractImage.
:Ivariables:
`region_class` : class (subclass of TextureRegion)
Class to use when constructing regions of this texture.
`tex_coords` : tuple
12-tuple of float, named (u1, v1, r1, u2, v2, r2, ...). u, v, r
give the 3D texture coordinates for vertices 1-4. The vertices
are specified in the order bottom-left, bottom-right, top-right
and top-left.
`target` : int
The GL texture target (e.g., ``GL_TEXTURE_2D``).
`level` : int
The mipmap level of this texture.
'''
region_class = None # Set to TextureRegion after it's defined
tex_coords = (0., 0., 0., 1., 0., 0., 1., 1., 0., 0., 1., 0.)
tex_coords_order = (0, 1, 2, 3)
level = 0
images = 1
x = y = z = 0
def __init__(self, width, height, target, id):
super(Texture, self).__init__(width, height)
self.target = target
self.id = id
self._context = gl.current_context
def delete(self):
'''Delete the texture from video memory.
:deprecated: Textures are automatically released during object
finalization.
'''
warnings.warn(
'Texture.delete() is deprecated; textures are '
'released through GC now')
self._context.delete_texture(self.id)
self.id = 0
def __del__(self):
try:
self._context.delete_texture(self.id)
except:
pass
@classmethod
def create(cls, width, height, internalformat=GL_RGBA,
rectangle=False, force_rectangle=False, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
'''Create an empty Texture.
If `rectangle` is ``False`` or the appropriate driver extensions are
not available, a larger texture than requested will be created, and
a `TextureRegion` corresponding to the requested size will be
returned.
:Parameters:
`width` : int
Width of the texture.
`height` : int
Height of the texture.
`internalformat` : int
GL constant giving the internal format of the texture; for
example, ``GL_RGBA``.
`rectangle` : bool
``True`` if a rectangular texture is permitted. See
`AbstractImage.get_texture`.
`force_rectangle` : bool
``True`` if a rectangular texture is required. See
`AbstractImage.get_texture`.
**Since:** pyglet 1.1.4.
`min_filter` : int
The minifaction filter used for this texture, commonly ``GL_LINEAR`` or ``GL_NEAREST``
`mag_filter` : int
The magnification filter used for this texture, commonly ``GL_LINEAR`` or ``GL_NEAREST``
:rtype: `Texture`
:since: pyglet 1.1
'''
target = GL_TEXTURE_2D
if rectangle or force_rectangle:
if not force_rectangle and _is_pow2(width) and _is_pow2(height):
rectangle = False
elif gl_info.have_extension('GL_ARB_texture_rectangle'):
target = GL_TEXTURE_RECTANGLE_ARB
rectangle = True
elif gl_info.have_extension('GL_NV_texture_rectangle'):
target = GL_TEXTURE_RECTANGLE_NV
rectangle = True
else:
rectangle = False
if force_rectangle and not rectangle:
raise ImageException('Texture rectangle extensions not available')
if rectangle:
texture_width = width
texture_height = height
else:
texture_width = _nearest_pow2(width)
texture_height = _nearest_pow2(height)
id = GLuint()
glGenTextures(1, byref(id))
glBindTexture(target, id.value)
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter)
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag_filter)
blank = (GLubyte * (texture_width * texture_height * 4))()
glTexImage2D(target, 0,
internalformat,
texture_width, texture_height,
0,
GL_RGBA, GL_UNSIGNED_BYTE,
blank)
texture = cls(texture_width, texture_height, target, id.value)
texture.min_filter = min_filter
texture.mag_filter = mag_filter
if rectangle:
texture._is_rectangle = True
texture.tex_coords = (0., 0., 0.,
width, 0., 0.,
width, height, 0.,
0., height, 0.)
glFlush()
if texture_width == width and texture_height == height:
return texture
return texture.get_region(0, 0, width, height)
@classmethod
def create_for_size(cls, target, min_width, min_height,
internalformat=None, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
'''Create a Texture with dimensions at least min_width, min_height.
On return, the texture will be bound.
:Parameters:
`target` : int
GL constant giving texture target to use, typically
``GL_TEXTURE_2D``.
`min_width` : int
Minimum width of texture (may be increased to create a power
of 2).
`min_height` : int
Minimum height of texture (may be increased to create a power
of 2).
`internalformat` : int
GL constant giving internal format of texture; for example,
``GL_RGBA``. If unspecified, the texture will not be
initialised (only the texture name will be created on the
instance). If specified, the image will be initialised
to this format with zero'd data.
`min_filter` : int
The minifaction filter used for this texture, commonly ``GL_LINEAR`` or ``GL_NEAREST``
`mag_filter` : int
The magnification filter used for this texture, commonly ``GL_LINEAR`` or ``GL_NEAREST``
:rtype: `Texture`
'''
if target not in (GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_RECTANGLE_ARB):
width = _nearest_pow2(min_width)
height = _nearest_pow2(min_height)
tex_coords = cls.tex_coords
else:
width = min_width
height = min_height
tex_coords = (0., 0., 0.,
width, 0., 0.,
width, height, 0.,
0., height, 0.)
id = GLuint()
glGenTextures(1, byref(id))
glBindTexture(target, id.value)
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter)
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag_filter)
if internalformat is not None:
blank = (GLubyte * (width * height * 4))()
glTexImage2D(target, 0,
internalformat,
width, height,
0,
GL_RGBA, GL_UNSIGNED_BYTE,
blank)
glFlush()
texture = cls(width, height, target, id.value)
texture.min_filter = min_filter
texture.mag_filter = mag_filter
texture.tex_coords = tex_coords
return texture
def get_image_data(self, z=0):
'''Get the image data of this texture.
Changes to the returned instance will not be reflected in this
texture.
:Parameters:
`z` : int
For 3D textures, the image slice to retrieve.
:rtype: `ImageData`
'''
glBindTexture(self.target, self.id)
# Always extract complete RGBA data. Could check internalformat
# to only extract used channels. XXX
format = 'RGBA'
gl_format = GL_RGBA
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT)
glPixelStorei(GL_PACK_ALIGNMENT, 1)
buffer = \
(GLubyte * (self.width * self.height * self.images * len(format)))()
glGetTexImage(self.target, self.level,
gl_format, GL_UNSIGNED_BYTE, buffer)
glPopClientAttrib()
data = ImageData(self.width, self.height, format, buffer)
if self.images > 1:
data = data.get_region(0, z * self.height, self.width, self.height)
return data
image_data = property(lambda self: self.get_image_data(),
doc='''An ImageData view of this texture.
Changes to the returned instance will not be reflected in this
texture. If the texture is a 3D texture, the first image will be
returned. See also `get_image_data`. Read-only.
:deprecated: Use `get_image_data`.
:type: `ImageData`
''')
def get_texture(self, rectangle=False, force_rectangle=False):
if force_rectangle and not self._is_rectangle:
raise ImageException('Texture is not a rectangle.')
return self
# no implementation of blit_to_texture yet (could use aux buffer)
def blit(self, x, y, z=0, width=None, height=None):
t = self.tex_coords
x1 = x - self.anchor_x
y1 = y - self.anchor_y
x2 = x1 + (width is None and self.width or width)
y2 = y1 + (height is None and self.height or height)
array = (GLfloat * 32)(
t[0], t[1], t[2], 1.,
x1, y1, z, 1.,
t[3], t[4], t[5], 1.,
x2, y1, z, 1.,
t[6], t[7], t[8], 1.,
x2, y2, z, 1.,
t[9], t[10], t[11], 1.,
x1, y2, z, 1.)
glPushAttrib(GL_ENABLE_BIT)
glEnable(self.target)
glBindTexture(self.target, self.id)
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT)
glInterleavedArrays(GL_T4F_V4F, 0, array)
glDrawArrays(GL_QUADS, 0, 4)
glPopClientAttrib()
glPopAttrib()
def blit_into(self, source, x, y, z):
glBindTexture(self.target, self.id)
source.blit_to_texture(self.target, self.level, x, y, z)
def get_region(self, x, y, width, height):
return self.region_class(x, y, 0, width, height, self)
def get_transform(self, flip_x=False, flip_y=False, rotate=0):
'''Create a copy of this image applying a simple transformation.
The transformation is applied to the texture coordinates only;
`get_image_data` will return the untransformed data. The
transformation is applied around the anchor point.
:Parameters:
`flip_x` : bool
If True, the returned image will be flipped horizontally.
`flip_y` : bool
If True, the returned image will be flipped vertically.
`rotate` : int
Degrees of clockwise rotation of the returned image. Only
90-degree increments are supported.
:rtype: `TextureRegion`
'''
transform = self.get_region(0, 0, self.width, self.height)
bl, br, tr, tl = 0, 1, 2, 3
transform.anchor_x = self.anchor_x
transform.anchor_y = self.anchor_y
if flip_x:
bl, br, tl, tr = br, bl, tr, tl
transform.anchor_x = self.width - self.anchor_x
if flip_y:
bl, br, tl, tr = tl, tr, bl, br
transform.anchor_y = self.height - self.anchor_y
rotate %= 360
if rotate < 0:
rotate += 360
if rotate == 0:
pass
elif rotate == 90:
bl, br, tr, tl = br, tr, tl, bl
transform.anchor_x, transform.anchor_y = \
transform.anchor_y, \
transform.width - transform.anchor_x
elif rotate == 180:
bl, br, tr, tl = tr, tl, bl, br
transform.anchor_x = transform.width - transform.anchor_x
transform.anchor_y = transform.height - transform.anchor_y
elif rotate == 270:
bl, br, tr, tl = tl, bl, br, tr
transform.anchor_x, transform.anchor_y = \
transform.height - transform.anchor_y, \
transform.anchor_x
else:
assert False, 'Only 90 degree rotations are supported.'
if rotate in (90, 270):
transform.width, transform.height = \
transform.height, transform.width
transform._set_tex_coords_order(bl, br, tr, tl)
return transform
def _set_tex_coords_order(self, bl, br, tr, tl):
tex_coords = (self.tex_coords[:3],
self.tex_coords[3:6],
self.tex_coords[6:9],
self.tex_coords[9:])
self.tex_coords = \
tex_coords[bl] + tex_coords[br] + tex_coords[tr] + tex_coords[tl]
order = self.tex_coords_order
self.tex_coords_order = \
(order[bl], order[br], order[tr], order[tl])
class TextureRegion(Texture):
'''A rectangular region of a texture, presented as if it were
a separate texture.
'''
def __init__(self, x, y, z, width, height, owner):
super(TextureRegion, self).__init__(
width, height, owner.target, owner.id)
self.x = x
self.y = y
self.z = z
self.owner = owner
owner_u1 = owner.tex_coords[0]
owner_v1 = owner.tex_coords[1]
owner_u2 = owner.tex_coords[3]
owner_v2 = owner.tex_coords[7]
scale_u = owner_u2 - owner_u1
scale_v = owner_v2 - owner_v1
u1 = x / owner.width * scale_u + owner_u1
v1 = y / owner.height * scale_v + owner_v1
u2 = (x + width) / owner.width * scale_u + owner_u1
v2 = (y + height) / owner.height * scale_v + owner_v1
r = z / owner.images + owner.tex_coords[2]
self.tex_coords = (u1, v1, r, u2, v1, r, u2, v2, r, u1, v2, r)
def get_image_data(self):
image_data = self.owner.get_image_data(self.z)
return image_data.get_region(self.x, self.y, self.width, self.height)
def get_region(self, x, y, width, height):
x += self.x
y += self.y
region = self.region_class(x, y, self.z, width, height, self.owner)
region._set_tex_coords_order(*self.tex_coords_order)
return region
def blit_into(self, source, x, y, z):
self.owner.blit_into(source, x + self.x, y + self.y, z + self.z)
def __del__(self):
# only the owner Texture should handle deletion
pass
Texture.region_class = TextureRegion
class Texture3D(Texture, UniformTextureSequence):
'''A texture with more than one image slice.
Use `create_for_images` or `create_for_image_grid` classmethod to
construct.
'''
item_width = 0
item_height = 0
items = ()
@classmethod
def create_for_images(cls, images, internalformat=GL_RGBA):
item_width = images[0].width
item_height = images[0].height
for image in images:
if image.width != item_width or image.height != item_height:
raise ImageException('Images do not have same dimensions.')
depth = len(images)
if not gl_info.have_version(2,0):
depth = _nearest_pow2(depth)
texture = cls.create_for_size(GL_TEXTURE_3D, item_width, item_height)
if images[0].anchor_x or images[0].anchor_y:
texture.anchor_x = images[0].anchor_x
texture.anchor_y = images[0].anchor_y
texture.images = depth
blank = (GLubyte * (texture.width * texture.height * texture.images))()
glBindTexture(texture.target, texture.id)
glTexImage3D(texture.target, texture.level,
internalformat,
texture.width, texture.height, texture.images, 0,
GL_ALPHA, GL_UNSIGNED_BYTE,
blank)
items = []
for i, image in enumerate(images):
item = cls.region_class(0, 0, i, item_width, item_height, texture)
items.append(item)
image.blit_to_texture(texture.target, texture.level,
image.anchor_x, image.anchor_y, i)
glFlush()
texture.items = items
texture.item_width = item_width
texture.item_height = item_height
return texture
@classmethod
def create_for_image_grid(cls, grid, internalformat=GL_RGBA):
return cls.create_for_images(grid[:], internalformat)
def __len__(self):
return len(self.items)
def __getitem__(self, index):
return self.items[index]
def __setitem__(self, index, value):
if type(index) is slice:
for item, image in zip(self[index], value):
image.blit_to_texture(self.target, self.level,
image.anchor_x, image.anchor_y, item.z)
else:
value.blit_to_texture(self.target, self.level,
value.anchor_x, value.anchor_y, self[index].z)
def __iter__(self):
return iter(self.items)
class TileableTexture(Texture):
'''A texture that can be tiled efficiently.
Use `create_for_image` classmethod to construct.
'''
def __init__(self, width, height, target, id):
if not _is_pow2(width) or not _is_pow2(height):
raise ImageException(
'TileableTexture requires dimensions that are powers of 2')
super(TileableTexture, self).__init__(width, height, target, id)
def get_region(self, x, y, width, height):
raise ImageException('Cannot get region of %r' % self)
def blit_tiled(self, x, y, z, width, height):
'''Blit this texture tiled over the given area.
The image will be tiled with the bottom-left corner of the destination
rectangle aligned with the anchor point of this texture.
'''
u1 = self.anchor_x / self.width
v1 = self.anchor_y / self.height
u2 = u1 + width / self.width
v2 = v1 + height / self.height
w, h = width, height
t = self.tex_coords
array = (GLfloat * 32)(
u1, v1, t[2], 1.,
x, y, z, 1.,
u2, v1, t[5], 1.,
x + w, y, z, 1.,
u2, v2, t[8], 1.,
x + w, y + h, z, 1.,
u1, v2, t[11], 1.,
x, y + h, z, 1.)
glPushAttrib(GL_ENABLE_BIT)
glEnable(self.target)
glBindTexture(self.target, self.id)
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT)
glInterleavedArrays(GL_T4F_V4F, 0, array)
glDrawArrays(GL_QUADS, 0, 4)
glPopClientAttrib()
glPopAttrib()
@classmethod
def create_for_image(cls, image):
if not _is_pow2(image.width) or not _is_pow2(image.height):
# Potentially unnecessary conversion if a GL format exists.
image = image.get_image_data()
texture_width = _nearest_pow2(image.width)
texture_height = _nearest_pow2(image.height)
newdata = c_buffer(texture_width * texture_height * 4)
gluScaleImage(GL_RGBA,
image.width, image.height,
GL_UNSIGNED_BYTE,
image.get_data('RGBA', image.width * 4),
texture_width,
texture_height,
GL_UNSIGNED_BYTE,
newdata)
image = ImageData(texture_width, texture_height, 'RGBA',
newdata)
image = image.get_image_data()
return image.create_texture(cls)
class DepthTexture(Texture):
'''A texture with depth samples (typically 24-bit).'''
def blit_into(self, source, x, y, z):
glBindTexture(self.target, self.id)
source.blit_to_texture(self.level, x, y, z)
class BufferManager(object):
'''Manages the set of framebuffers for a context.
Use `get_buffer_manager` to obtain the instance of this class for the
current context.
'''
def __init__(self):
self.color_buffer = None
self.depth_buffer = None
aux_buffers = GLint()
glGetIntegerv(GL_AUX_BUFFERS, byref(aux_buffers))
self.free_aux_buffers = [GL_AUX0,
GL_AUX1,
GL_AUX2,
GL_AUX3][:aux_buffers.value]
stencil_bits = GLint()
glGetIntegerv(GL_STENCIL_BITS, byref(stencil_bits))
self.free_stencil_bits = range(stencil_bits.value)
self.refs = []
def get_viewport(self):
'''Get the current OpenGL viewport dimensions.
:rtype: 4-tuple of float.
:return: Left, top, right and bottom dimensions.
'''
viewport = (GLint * 4)()
glGetIntegerv(GL_VIEWPORT, viewport)
return viewport
def get_color_buffer(self):
'''Get the color buffer.
:rtype: `ColorBufferImage`
'''
viewport = self.get_viewport()
viewport_width = viewport[2]
viewport_height = viewport[3]
if (not self.color_buffer or
viewport_width != self.color_buffer.width or
viewport_height != self.color_buffer.height):
self.color_buffer = ColorBufferImage(*viewport)
return self.color_buffer
def get_aux_buffer(self):
'''Get a free auxiliary buffer.
If not aux buffers are available, `ImageException` is raised. Buffers
are released when they are garbage collected.
:rtype: `ColorBufferImage`
'''
if not self.free_aux_buffers:
raise ImageException('No free aux buffer is available.')
gl_buffer = self.free_aux_buffers.pop(0)
viewport = self.get_viewport()
buffer = ColorBufferImage(*viewport)
buffer.gl_buffer = gl_buffer
def release_buffer(ref, self=self):
self.free_aux_buffers.insert(0, gl_buffer)
self.refs.append(weakref.ref(buffer, release_buffer))
return buffer
def get_depth_buffer(self):
'''Get the depth buffer.
:rtype: `DepthBufferImage`
'''
viewport = self.get_viewport()
viewport_width = viewport[2]
viewport_height = viewport[3]
if (not self.depth_buffer or
viewport_width != self.depth_buffer.width or
viewport_height != self.depth_buffer.height):
self.depth_buffer = DepthBufferImage(*viewport)
return self.depth_buffer
def get_buffer_mask(self):
'''Get a free bitmask buffer.
A bitmask buffer is a buffer referencing a single bit in the stencil
buffer. If no bits are free, `ImageException` is raised. Bits are
released when the bitmask buffer is garbage collected.
:rtype: `BufferImageMask`
'''
if not self.free_stencil_bits:
raise ImageException('No free stencil bits are available.')
stencil_bit = self.free_stencil_bits.pop(0)
x, y, width, height = self.get_viewport()
buffer = BufferImageMask(x, y, width, height)
buffer.stencil_bit = stencil_bit
def release_buffer(ref, self=self):
self.free_stencil_bits.insert(0, stencil_bit)
self.refs.append(weakref.ref(buffer, release_buffer))
return buffer
def get_buffer_manager():
'''Get the buffer manager for the current OpenGL context.
:rtype: `BufferManager`
'''
context = gl.current_context
if not hasattr(context, 'image_buffer_manager'):
context.image_buffer_manager = BufferManager()
return context.image_buffer_manager
# XXX BufferImage could be generalised to support EXT_framebuffer_object's
# renderbuffer.
class BufferImage(AbstractImage):
'''An abstract framebuffer.
'''
#: The OpenGL read and write target for this buffer.
gl_buffer = GL_BACK
#: The OpenGL format constant for image data.
gl_format = 0
#: The format string used for image data.
format = ''
owner = None
# TODO: enable methods
def __init__(self, x, y, width, height):
self.x = x
self.y = y
self.width = width
self.height = height
def get_image_data(self):
buffer = (GLubyte * (len(self.format) * self.width * self.height))()
x = self.x
y = self.y
if self.owner:
x += self.owner.x
y += self.owner.y
glReadBuffer(self.gl_buffer)
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT)
glPixelStorei(GL_PACK_ALIGNMENT, 1)
glReadPixels(x, y, self.width, self.height,
self.gl_format, GL_UNSIGNED_BYTE, buffer)
glPopClientAttrib()
return ImageData(self.width, self.height, self.format, buffer)
def get_region(self, x, y, width, height):
if self.owner:
return self.owner.get_region(x + self.x, y + self.y, width, height)
region = self.__class__(x + self.x, y + self.y, width, height)
region.gl_buffer = self.gl_buffer
region.owner = self
return region
class ColorBufferImage(BufferImage):
'''A color framebuffer.
This class is used to wrap both the primary color buffer (i.e., the back
buffer) or any one of the auxiliary buffers.
'''
gl_format = GL_RGBA
format = 'RGBA'
def get_texture(self, rectangle=False, force_rectangle=False):
texture = Texture.create(self.width, self.height, GL_RGBA,
rectangle, force_rectangle)
self.blit_to_texture(texture.target, texture.level,
self.anchor_x, self.anchor_y, 0)
return texture
def blit_to_texture(self, target, level, x, y, z):
glReadBuffer(self.gl_buffer)
glCopyTexSubImage2D(target, level,
x - self.anchor_x, y - self.anchor_y,
self.x, self.y, self.width, self.height)
class DepthBufferImage(BufferImage):
'''The depth buffer.
'''
gl_format = GL_DEPTH_COMPONENT
format = 'L'
def get_texture(self, rectangle=False, force_rectangle=False):
assert rectangle == False and force_rectangle == False, \
'Depth textures cannot be rectangular'
if not _is_pow2(self.width) or not _is_pow2(self.height):
raise ImageException(
'Depth texture requires that buffer dimensions be powers of 2')
texture = DepthTexture.create_for_size(GL_TEXTURE_2D,
self.width, self.height)
if self.anchor_x or self.anchor_y:
texture.anchor_x = self.anchor_x
texture.anchor_y = self.anchor_y
glReadBuffer(self.gl_buffer)
glCopyTexImage2D(texture.target, 0,
GL_DEPTH_COMPONENT,
self.x, self.y, self.width, self.height,
0)
return texture
def blit_to_texture(self, target, level, x, y, z):
glReadBuffer(self.gl_buffer)
glCopyTexSubImage2D(target, level,
x - self.anchor_x, y - self.anchor_y,
self.x, self.y, self.width, self.height)
class BufferImageMask(BufferImage):
'''A single bit of the stencil buffer.
'''
gl_format = GL_STENCIL_INDEX
format = 'L'
# TODO mask methods
class ImageGrid(AbstractImage, AbstractImageSequence):
'''An imaginary grid placed over an image allowing easy access to
regular regions of that image.
The grid can be accessed either as a complete image, or as a sequence
of images. The most useful applications are to access the grid
as a `TextureGrid`::
image_grid = ImageGrid(...)
texture_grid = image_grid.get_texture_sequence()
or as a `Texture3D`::
image_grid = ImageGrid(...)
texture_3d = Texture3D.create_for_image_grid(image_grid)
'''
_items = ()
_texture_grid = None
def __init__(self, image, rows, columns,
item_width=None, item_height=None,
row_padding=0, column_padding=0):
'''Construct a grid for the given image.
You can specify parameters for the grid, for example setting
the padding between cells. Grids are always aligned to the
bottom-left corner of the image.
:Parameters:
`image` : AbstractImage
Image over which to construct the grid.
`rows` : int
Number of rows in the grid.
`columns` : int
Number of columns in the grid.
`item_width` : int
Width of each column. If unspecified, is calculated such
that the entire image width is used.
`item_height` : int
Height of each row. If unspecified, is calculated such that
the entire image height is used.
`row_padding` : int
Pixels separating adjacent rows. The padding is only
inserted between rows, not at the edges of the grid.
`column_padding` : int
Pixels separating adjacent columns. The padding is only
inserted between columns, not at the edges of the grid.
'''
super(ImageGrid, self).__init__(image.width, image.height)
if item_width is None:
item_width = \
(image.width - column_padding * (columns - 1)) // columns
if item_height is None:
item_height = \
(image.height - row_padding * (rows - 1)) // rows
self.image = image
self.rows = rows
self.columns = columns
self.item_width = item_width
self.item_height = item_height
self.row_padding = row_padding
self.column_padding = column_padding
def get_texture(self, rectangle=False, force_rectangle=False):
return self.image.get_texture(rectangle, force_rectangle)
def get_image_data(self):
return self.image.get_image_data()
def get_texture_sequence(self):
if not self._texture_grid:
self._texture_grid = TextureGrid(self)
return self._texture_grid
def __len__(self):
return self.rows * self.columns
def _update_items(self):
if not self._items:
self._items = []
y = 0
for row in range(self.rows):
x = 0
for col in range(self.columns):
self._items.append(self.image.get_region(
x, y, self.item_width, self.item_height))
x += self.item_width + self.column_padding
y += self.item_height + self.row_padding
def __getitem__(self, index):
self._update_items()
if type(index) is tuple:
row, column = index
assert row >= 0 and column >= 0 and \
row < self.rows and column < self.columns
return self._items[row * self.columns + column]
else:
return self._items[index]
def __iter__(self):
self._update_items()
return iter(self._items)
class TextureGrid(TextureRegion, UniformTextureSequence):
'''A texture containing a regular grid of texture regions.
To construct, create an `ImageGrid` first::
image_grid = ImageGrid(...)
texture_grid = TextureGrid(image_grid)
The texture grid can be accessed as a single texture, or as a sequence
of `TextureRegion`. When accessing as a sequence, you can specify
integer indexes, in which the images are arranged in rows from the
bottom-left to the top-right::
# assume the texture_grid is 3x3:
current_texture = texture_grid[3] # get the middle-left image
You can also specify tuples in the sequence methods, which are addressed
as ``row, column``::
# equivalent to the previous example:
current_texture = texture_grid[1, 0]
When using tuples in a slice, the returned sequence is over the
rectangular region defined by the slice::
# returns center, center-right, center-top, top-right images in that
# order:
images = texture_grid[(1,1):]
# equivalent to
images = texture_grid[(1,1):(3,3)]
'''
items = ()
rows = 1
columns = 1
item_width = 0
item_height = 0
def __init__(self, grid):
image = grid.get_texture()
if isinstance(image, TextureRegion):
owner = image.owner
else:
owner = image
super(TextureGrid, self).__init__(
image.x, image.y, image.z, image.width, image.height, owner)
items = []
y = 0
for row in range(grid.rows):
x = 0
for col in range(grid.columns):
items.append(
self.get_region(x, y, grid.item_width, grid.item_height))
x += grid.item_width + grid.column_padding
y += grid.item_height + grid.row_padding
self.items = items
self.rows = grid.rows
self.columns = grid.columns
self.item_width = grid.item_width
self.item_height = grid.item_height
def get(self, row, column):
return self[(row, column)]
def __getitem__(self, index):
if type(index) is slice:
if type(index.start) is not tuple and \
type(index.stop) is not tuple:
return self.items[index]
else:
row1 = 0
col1 = 0
row2 = self.rows
col2 = self.columns
if type(index.start) is tuple:
row1, col1 = index.start
elif type(index.start) is int:
row1 = index.start // self.columns
col1 = index.start % self.columns
assert row1 >= 0 and col1 >= 0 and \
row1 < self.rows and col1 < self.columns
if type(index.stop) is tuple:
row2, col2 = index.stop
elif type(index.stop) is int:
row2 = index.stop // self.columns
col2 = index.stop % self.columns
assert row2 >= 0 and col2 >= 0 and \
row2 <= self.rows and col2 <= self.columns
result = []
i = row1 * self.columns
for row in range(row1, row2):
result += self.items[i+col1:i+col2]
i += self.columns
return result
else:
if type(index) is tuple:
row, column = index
assert row >= 0 and column >= 0 and \
row < self.rows and column < self.columns
return self.items[row * self.columns + column]
elif type(index) is int:
return self.items[index]
def __setitem__(self, index, value):
if type(index) is slice:
for region, image in zip(self[index], value):
if image.width != self.item_width or \
image.height != self.item_height:
raise ImageException('Image has incorrect dimensions')
image.blit_into(region, image.anchor_x, image.anchor_y, 0)
else:
image = value
if image.width != self.item_width or \
image.height != self.item_height:
raise ImageException('Image has incorrect dimensions')
image.blit_into(self[index], image.anchor_x, image.anchor_y, 0)
def __len__(self):
return len(self.items)
def __iter__(self):
return iter(self.items)
# --------------------------------------------------------------------------
# Animation stuff here. Vote on if this should be in pyglet.image.animation
# or just leave it tacked on here.
# TODO:
# conversion Animation -> media.Source
# move to another module?
# pyglet.animation?
# pyglet.image.animation?
def load_animation(filename, file=None, decoder=None):
'''Load an animation from a file.
Currently, the only supported format is GIF.
:Parameters:
`filename` : str
Used to guess the animation format, and to load the file if `file`
is unspecified.
`file` : file-like object or None
File object containing the animation stream.
`decoder` : ImageDecoder or None
If unspecified, all decoders that are registered for the filename
extension are tried. If none succeed, the exception from the
first decoder is raised.
:rtype: Animation
'''
if not file:
file = open(filename, 'rb')
if not hasattr(file, 'seek'):
file = BytesIO(file.read())
if decoder:
return decoder.decode(file, filename)
else:
first_exception = None
for decoder in codecs.get_animation_decoders(filename):
try:
image = decoder.decode_animation(file, filename)
return image
except codecs.ImageDecodeException, e:
first_exception = first_exception or e
file.seek(0)
if not first_exception:
raise codecs.ImageDecodeException('No image decoders are available')
raise first_exception
class Animation(object):
'''Sequence of images with timing information.
If no frames of the animation have a duration of ``None``, the animation
loops continuously; otherwise the animation stops at the first frame with
duration of ``None``.
:Ivariables:
`frames` : list of `AnimationFrame`
The frames that make up the animation.
'''
def __init__(self, frames):
'''Create an animation directly from a list of frames.
:Parameters:
`frames` : list of `AnimationFrame`
The frames that make up the animation.
'''
assert len(frames)
self.frames = frames
def add_to_texture_bin(self, bin):
'''Add the images of the animation to a `TextureBin`.
The animation frames are modified in-place to refer to the texture bin
regions.
:Parameters:
`bin` : `TextureBin`
Texture bin to upload animation frames into.
'''
for frame in self.frames:
frame.image = bin.add(frame.image)
def get_transform(self, flip_x=False, flip_y=False, rotate=0):
'''Create a copy of this animation applying a simple transformation.
The transformation is applied around the image's anchor point of
each frame. The texture data is shared between the original animation
and the transformed animation.
:Parameters:
`flip_x` : bool
If True, the returned animation will be flipped horizontally.
`flip_y` : bool
If True, the returned animation will be flipped vertically.
`rotate` : int
Degrees of clockwise rotation of the returned animation. Only
90-degree increments are supported.
:rtype: `Animation`
'''
frames = [AnimationFrame(
frame.image.get_texture().get_transform(
flip_x, flip_y, rotate), frame.duration) \
for frame in self.frames]
return Animation(frames)
def get_duration(self):
'''Get the total duration of the animation in seconds.
:rtype: float
'''
return sum([frame.duration for frame in self.frames \
if frame.duration is not None])
def get_max_width(self):
'''Get the maximum image frame width.
This method is useful for determining texture space requirements: due
to the use of ``anchor_x`` the actual required playback area may be
larger.
:rtype: int
'''
return max([frame.image.width for frame in self.frames])
def get_max_height(self):
'''Get the maximum image frame height.
This method is useful for determining texture space requirements: due
to the use of ``anchor_y`` the actual required playback area may be
larger.
:rtype: int
'''
return max([frame.image.height for frame in self.frames])
@classmethod
def from_image_sequence(cls, sequence, period, loop=True):
'''Create an animation from a list of images and a constant framerate.
:Parameters:
`sequence` : list of `AbstractImage`
Images that make up the animation, in sequence.
`period` : float
Number of seconds to display each image.
`loop` : bool
If True, the animation will loop continuously.
:rtype: `Animation`
'''
frames = [AnimationFrame(image, period) for image in sequence]
if not loop:
frames[-1].duration = None
return cls(frames)
class AnimationFrame(object):
'''A single frame of an animation.
'''
def __init__(self, image, duration):
'''Create an animation frame from an image.
:Parameters:
`image` : `AbstractImage`
The image of this frame.
`duration` : float
Number of seconds to display the frame, or ``None`` if it is
the last frame in the animation.
'''
self.image = image
self.duration = duration
def __repr__(self):
return 'AnimationFrame(%r, %r)' % (self.image, self.duration)
# Initialise default codecs
from pyglet.image import codecs as _codecs
_codecs.add_default_image_codecs()
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Display positioned, scaled and rotated images.
A sprite is an instance of an image displayed on-screen. Multiple sprites can
display the same image at different positions on the screen. Sprites can also
be scaled larger or smaller, rotated at any angle and drawn at a fractional
opacity.
The following complete example loads a ``"ball.png"`` image and creates a
sprite for that image. The sprite is then drawn in the window's
draw event handler::
import pyglet
ball_image = pyglet.image.load('ball.png')
ball = pyglet.sprite.Sprite(ball_image, x=50, y=50)
window = pyglet.window.Window()
@window.event
def on_draw():
ball.draw()
pyglet.app.run()
The sprite can be moved by modifying the ``x`` and ``y`` properties. Other
properties determine the sprite's rotation, scale and opacity.
By default sprite coordinates are restricted to integer values to avoid
sub-pixel artifacts. If you require to use floats, for example for smoother
animations, you can set the ``subpixel`` parameter to ``True`` when creating
the sprite (:since: pyglet 1.2).
The sprite's positioning, rotation and scaling all honor the original
image's anchor (anchor_x, anchor_y).
Drawing multiple sprites
========================
Sprites can be "batched" together and drawn at once more quickly than if each
of their ``draw`` methods were called individually. The following example
creates one hundred ball sprites and adds each of them to a `Batch`. The
entire batch of sprites is then drawn in one call::
batch = pyglet.graphics.Batch()
ball_sprites = []
for i in range(100):
x, y = i * 10, 50
ball_sprites.append(pyglet.sprite.Sprite(ball_image, x, y, batch=batch))
@window.event
def on_draw():
batch.draw()
Sprites can be freely modified in any way even after being added to a batch,
however a sprite can belong to at most one batch. See the documentation for
`pyglet.graphics` for more details on batched rendering, and grouping of
sprites within batches.
:since: pyglet 1.1
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import math
import sys
from pyglet.gl import *
from pyglet import clock
from pyglet import event
from pyglet import graphics
from pyglet import image
_is_epydoc = hasattr(sys, 'is_epydoc') and sys.is_epydoc
class SpriteGroup(graphics.Group):
'''Shared sprite rendering group.
The group is automatically coalesced with other sprite groups sharing the
same parent group, texture and blend parameters.
'''
def __init__(self, texture, blend_src, blend_dest, parent=None):
'''Create a sprite group.
The group is created internally within `Sprite`; applications usually
do not need to explicitly create it.
:Parameters:
`texture` : `Texture`
The (top-level) texture containing the sprite image.
`blend_src` : int
OpenGL blend source mode; for example,
``GL_SRC_ALPHA``.
`blend_dest` : int
OpenGL blend destination mode; for example,
``GL_ONE_MINUS_SRC_ALPHA``.
`parent` : `Group`
Optional parent group.
'''
super(SpriteGroup, self).__init__(parent)
self.texture = texture
self.blend_src = blend_src
self.blend_dest = blend_dest
def set_state(self):
glEnable(self.texture.target)
glBindTexture(self.texture.target, self.texture.id)
glPushAttrib(GL_COLOR_BUFFER_BIT)
glEnable(GL_BLEND)
glBlendFunc(self.blend_src, self.blend_dest)
def unset_state(self):
glPopAttrib()
glDisable(self.texture.target)
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.texture)
def __eq__(self, other):
return (other.__class__ is self.__class__ and
self.parent is other.parent and
self.texture.target == other.texture.target and
self.texture.id == other.texture.id and
self.blend_src == other.blend_src and
self.blend_dest == other.blend_dest)
def __hash__(self):
return hash((id(self.parent),
self.texture.id, self.texture.target,
self.blend_src, self.blend_dest))
class Sprite(event.EventDispatcher):
'''Instance of an on-screen image.
See the module documentation for usage.
'''
_batch = None
_animation = None
_rotation = 0
_opacity = 255
_rgb = (255, 255, 255)
_scale = 1.0
_visible = True
_vertex_list = None
def __init__(self,
img, x=0, y=0,
blend_src=GL_SRC_ALPHA,
blend_dest=GL_ONE_MINUS_SRC_ALPHA,
batch=None,
group=None,
usage='dynamic',
subpixel=False):
'''Create a sprite.
:Parameters:
`img` : `AbstractImage` or `Animation`
Image or animation to display.
`x` : int
X coordinate of the sprite.
`y` : int
Y coordinate of the sprite.
`blend_src` : int
OpenGL blend source mode. The default is suitable for
compositing sprites drawn from back-to-front.
`blend_dest` : int
OpenGL blend destination mode. The default is suitable for
compositing sprites drawn from back-to-front.
`batch` : `Batch`
Optional batch to add the sprite to.
`group` : `Group`
Optional parent group of the sprite.
`usage` : str
Vertex buffer object usage hint, one of ``"none"``,
``"stream"``, ``"dynamic"`` (default) or ``"static"``. Applies
only to vertex data.
`subpixel` : bool
Allow floating-point coordinates for the sprite. By default,
coordinates are restricted to integer values.
'''
if batch is not None:
self._batch = batch
self._x = x
self._y = y
if isinstance(img, image.Animation):
self._animation = img
self._frame_index = 0
self._texture = img.frames[0].image.get_texture()
self._next_dt = img.frames[0].duration
if self._next_dt:
clock.schedule_once(self._animate, self._next_dt)
else:
self._texture = img.get_texture()
self._group = SpriteGroup(self._texture, blend_src, blend_dest, group)
self._usage = usage
self._subpixel = subpixel
self._create_vertex_list()
def __del__(self):
try:
if self._vertex_list is not None:
self._vertex_list.delete()
except:
pass
def delete(self):
'''Force immediate removal of the sprite from video memory.
This is often necessary when using batches, as the Python garbage
collector will not necessarily call the finalizer as soon as the
sprite is garbage.
'''
if self._animation:
clock.unschedule(self._animate)
self._vertex_list.delete()
self._vertex_list = None
self._texture = None
# Easy way to break circular reference, speeds up GC
self._group = None
def _animate(self, dt):
self._frame_index += 1
if self._frame_index >= len(self._animation.frames):
self._frame_index = 0
self.dispatch_event('on_animation_end')
if self._vertex_list is None:
return # Deleted in event handler.
frame = self._animation.frames[self._frame_index]
self._set_texture(frame.image.get_texture())
if frame.duration is not None:
duration = frame.duration - (self._next_dt - dt)
duration = min(max(0, duration), frame.duration)
clock.schedule_once(self._animate, duration)
self._next_dt = duration
else:
self.dispatch_event('on_animation_end')
def _set_batch(self, batch):
if self._batch == batch:
return
if batch is not None and self._batch is not None:
self._batch.migrate(self._vertex_list, GL_QUADS, self._group, batch)
self._batch = batch
else:
self._vertex_list.delete()
self._batch = batch
self._create_vertex_list()
def _get_batch(self):
return self._batch
batch = property(_get_batch, _set_batch,
doc='''Graphics batch.
The sprite can be migrated from one batch to another, or removed from its
batch (for individual drawing). Note that this can be an expensive
operation.
:type: `Batch`
''')
def _set_group(self, group):
if self._group.parent == group:
return
self._group = SpriteGroup(self._texture,
self._group.blend_src,
self._group.blend_dest,
group)
if self._batch is not None:
self._batch.migrate(self._vertex_list, GL_QUADS, self._group,
self._batch)
def _get_group(self):
return self._group.parent
group = property(_get_group, _set_group,
doc='''Parent graphics group.
The sprite can change its rendering group, however this can be an
expensive operation.
:type: `Group`
''')
def _get_image(self):
if self._animation:
return self._animation
return self._texture
def _set_image(self, img):
if self._animation is not None:
clock.unschedule(self._animate)
self._animation = None
if isinstance(img, image.Animation):
self._animation = img
self._frame_index = 0
self._set_texture(img.frames[0].image.get_texture())
self._next_dt = img.frames[0].duration
if self._next_dt:
clock.schedule_once(self._animate, self._next_dt)
else:
self._set_texture(img.get_texture())
self._update_position()
image = property(_get_image, _set_image,
doc='''Image or animation to display.
:type: `AbstractImage` or `Animation`
''')
def _set_texture(self, texture):
if texture.id is not self._texture.id:
self._group = SpriteGroup(texture,
self._group.blend_src,
self._group.blend_dest,
self._group.parent)
if self._batch is None:
self._vertex_list.tex_coords[:] = texture.tex_coords
else:
self._vertex_list.delete()
self._texture = texture
self._create_vertex_list()
else:
self._vertex_list.tex_coords[:] = texture.tex_coords
self._texture = texture
def _create_vertex_list(self):
if self._subpixel:
vertex_format = 'v2f/%s' % self._usage
else:
vertex_format = 'v2i/%s' % self._usage
if self._batch is None:
self._vertex_list = graphics.vertex_list(4,
vertex_format,
'c4B', ('t3f', self._texture.tex_coords))
else:
self._vertex_list = self._batch.add(4, GL_QUADS, self._group,
vertex_format,
'c4B', ('t3f', self._texture.tex_coords))
self._update_position()
self._update_color()
def _update_position(self):
img = self._texture
if not self._visible:
vertices = [0, 0, 0, 0, 0, 0, 0, 0]
elif self._rotation:
x1 = -img.anchor_x * self._scale
y1 = -img.anchor_y * self._scale
x2 = x1 + img.width * self._scale
y2 = y1 + img.height * self._scale
x = self._x
y = self._y
r = -math.radians(self._rotation)
cr = math.cos(r)
sr = math.sin(r)
ax = x1 * cr - y1 * sr + x
ay = x1 * sr + y1 * cr + y
bx = x2 * cr - y1 * sr + x
by = x2 * sr + y1 * cr + y
cx = x2 * cr - y2 * sr + x
cy = x2 * sr + y2 * cr + y
dx = x1 * cr - y2 * sr + x
dy = x1 * sr + y2 * cr + y
vertices = [ax, ay, bx, by, cx, cy, dx, dy]
elif self._scale != 1.0:
x1 = self._x - img.anchor_x * self._scale
y1 = self._y - img.anchor_y * self._scale
x2 = x1 + img.width * self._scale
y2 = y1 + img.height * self._scale
vertices = [x1, y1, x2, y1, x2, y2, x1, y2]
else:
x1 = self._x - img.anchor_x
y1 = self._y - img.anchor_y
x2 = x1 + img.width
y2 = y1 + img.height
vertices = [x1, y1, x2, y1, x2, y2, x1, y2]
if not self._subpixel:
vertices = [int(v) for v in vertices]
self._vertex_list.vertices[:] = vertices
def _update_color(self):
r, g, b = self._rgb
self._vertex_list.colors[:] = [r, g, b, int(self._opacity)] * 4
def set_position(self, x, y):
'''Set the X and Y coordinates of the sprite simultaneously.
:Parameters:
`x` : int
X coordinate of the sprite.
`y` : int
Y coordinate of the sprite.
'''
self._x = x
self._y = y
self._update_position()
position = property(lambda self: (self._x, self._y),
lambda self, t: self.set_position(*t),
doc='''The (x, y) coordinates of the sprite.
:type: (int, int)
''')
def _set_x(self, x):
self._x = x
self._update_position()
x = property(lambda self: self._x, _set_x,
doc='''X coordinate of the sprite.
:type: int
''')
def _set_y(self, y):
self._y = y
self._update_position()
y = property(lambda self: self._y, _set_y,
doc='''Y coordinate of the sprite.
:type: int
''')
def _set_rotation(self, rotation):
self._rotation = rotation
self._update_position()
rotation = property(lambda self: self._rotation, _set_rotation,
doc='''Clockwise rotation of the sprite, in degrees.
The sprite image will be rotated about its image's (anchor_x, anchor_y)
position.
:type: float
''')
def _set_scale(self, scale):
self._scale = scale
self._update_position()
scale = property(lambda self: self._scale, _set_scale,
doc='''Scaling factor.
A scaling factor of 1 (the default) has no effect. A scale of 2 will draw
the sprite at twice the native size of its image.
:type: float
''')
def _get_width(self):
if self._subpixel:
return self._texture.width * self._scale
else:
return int(self._texture.width * self._scale)
width = property(_get_width,
doc='''Scaled width of the sprite.
Read-only. Invariant under rotation.
:type: int
''')
def _get_height(self):
if self._subpixel:
return self._texture.height * self._scale
else:
return int(self._texture.height * self._scale)
height = property(_get_height,
doc='''Scaled height of the sprite.
Read-only. Invariant under rotation.
:type: int
''')
def _set_opacity(self, opacity):
self._opacity = opacity
self._update_color()
opacity = property(lambda self: self._opacity, _set_opacity,
doc='''Blend opacity.
This property sets the alpha component of the colour of the sprite's
vertices. With the default blend mode (see the constructor), this
allows the sprite to be drawn with fractional opacity, blending with the
background.
An opacity of 255 (the default) has no effect. An opacity of 128 will
make the sprite appear translucent.
:type: int
''')
def _set_color(self, rgb):
self._rgb = map(int, rgb)
self._update_color()
color = property(lambda self: self._rgb, _set_color,
doc='''Blend color.
This property sets the color of the sprite's vertices. This allows the
sprite to be drawn with a color tint.
The color is specified as an RGB tuple of integers ``(red, green, blue)``.
Each color component must be in the range 0 (dark) to 255 (saturated).
:type: (int, int, int)
''')
def _set_visible(self, visible):
self._visible = visible
self._update_position()
visible = property(lambda self: self._visible, _set_visible,
'''True if the sprite will be drawn.
:type: bool
''')
def draw(self):
'''Draw the sprite at its current position.
See the module documentation for hints on drawing multiple sprites
efficiently.
'''
self._group.set_state_recursive()
self._vertex_list.draw(GL_QUADS)
self._group.unset_state_recursive()
if _is_epydoc:
def on_animation_end(self):
'''The sprite animation reached the final frame.
The event is triggered only if the sprite has an animation, not an
image. For looping animations, the event is triggered each time
the animation loops.
:event:
'''
Sprite.register_event_type('on_animation_end')
| Python |
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# * Neither the name of pyglet nor the names of its
# contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------
'''Compatibility tools
Various tools for simultaneous Python 2.x and Python 3.x support
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import sys
import itertools
if sys.version_info[0] == 2:
if sys.version_info[1] < 6:
#Pure Python implementation from
#http://docs.python.org/library/itertools.html#itertools.izip_longest
def izip_longest(*args, **kwds):
# izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
fillvalue = kwds.get('fillvalue')
def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
yield counter() # yields the fillvalue, or raises IndexError
fillers = itertools.repeat(fillvalue)
iters = [itertools.chain(it, sentinel(), fillers) for it in args]
try:
for tup in itertools.izip(*iters):
yield tup
except IndexError:
pass
else:
izip_longest = itertools.izip_longest
else:
izip_longest = itertools.zip_longest
if sys.version_info[0] >= 3:
import io
def asbytes(s):
if isinstance(s, bytes):
return s
elif isinstance(s, str):
return bytes(ord(c) for c in s)
else:
return bytes(s)
def asbytes_filename(s):
if isinstance(s, bytes):
return s
elif isinstance(s, str):
return s.encode(encoding=sys.getfilesystemencoding())
def asstr(s):
if isinstance(s, str):
return s
return s.decode("utf-8")
bytes_type = bytes
BytesIO = io.BytesIO
else:
import StringIO
asbytes = str
asbytes_filename = str
asstr = str
bytes_type = str
BytesIO = StringIO.StringIO
| Python |
#!/usr/bin/env python
'''Generate a Python ctypes wrapper file for a header file.
Usage example::
wrap.py -lGL -oGL.py /usr/include/GL/gl.h
>>> from GL import *
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypesparser import *
import textwrap
import sys
class CtypesWrapper(CtypesParser, CtypesTypeVisitor):
file=None
def begin_output(self, output_file, library, link_modules=(),
emit_filenames=(), all_headers=False):
self.library = library
self.file = output_file
self.all_names = []
self.known_types = {}
self.structs = set()
self.enums = set()
self.emit_filenames = emit_filenames
self.all_headers = all_headers
self.linked_symbols = {}
for name in link_modules:
module = __import__(name, globals(), locals(), ['foo'])
for symbol in dir(module):
if symbol not in self.linked_symbols:
self.linked_symbols[symbol] = '%s.%s' % (name, symbol)
self.link_modules = link_modules
self.print_preamble()
self.print_link_modules_imports()
def wrap(self, filename, source=None):
assert self.file, 'Call begin_output first'
self.parse(filename, source)
def end_output(self):
self.print_epilogue()
self.file = None
def does_emit(self, symbol, filename):
return self.all_headers or filename in self.emit_filenames
def print_preamble(self):
import textwrap
import time
print >> self.file, textwrap.dedent("""
'''Wrapper for %(library)s
Generated with:
%(argv)s
Do not modify this file.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
from ctypes import *
import pyglet.lib
_lib = pyglet.lib.load_library(%(library)r)
_int_types = (c_int16, c_int32)
if hasattr(ctypes, 'c_int64'):
# Some builds of ctypes apparently do not have c_int64
# defined; it's a pretty good bet that these builds do not
# have 64-bit pointers.
_int_types += (ctypes.c_int64,)
for t in _int_types:
if sizeof(t) == sizeof(c_size_t):
c_ptrdiff_t = t
class c_void(Structure):
# c_void_p is a buggy return type, converting to int, so
# POINTER(None) == c_void_p is actually written as
# POINTER(c_void), so it can be treated as a real pointer.
_fields_ = [('dummy', c_int)]
""" % {
'library': self.library,
'date': time.ctime(),
'class': self.__class__.__name__,
'argv': ' '.join(sys.argv),
}).lstrip()
def print_link_modules_imports(self):
for name in self.link_modules:
print >> self.file, 'import %s' % name
print >> self.file
def print_epilogue(self):
print >> self.file
print >> self.file, '\n'.join(textwrap.wrap(
'__all__ = [%s]' % ', '.join([repr(n) for n in self.all_names]),
width=78,
break_long_words=False))
def handle_ctypes_constant(self, name, value, filename, lineno):
if self.does_emit(name, filename):
print >> self.file, '%s = %r' % (name, value),
print >> self.file, '\t# %s:%d' % (filename, lineno)
self.all_names.append(name)
def handle_ctypes_type_definition(self, name, ctype, filename, lineno):
if self.does_emit(name, filename):
self.all_names.append(name)
if name in self.linked_symbols:
print >> self.file, '%s = %s' % \
(name, self.linked_symbols[name])
else:
ctype.visit(self)
self.emit_type(ctype)
print >> self.file, '%s = %s' % (name, str(ctype)),
print >> self.file, '\t# %s:%d' % (filename, lineno)
else:
self.known_types[name] = (ctype, filename, lineno)
def emit_type(self, t):
t.visit(self)
for s in t.get_required_type_names():
if s in self.known_types:
if s in self.linked_symbols:
print >> self.file, '%s = %s' % (s, self.linked_symbols[s])
else:
s_ctype, s_filename, s_lineno = self.known_types[s]
s_ctype.visit(self)
self.emit_type(s_ctype)
print >> self.file, '%s = %s' % (s, str(s_ctype)),
print >> self.file, '\t# %s:%d' % (s_filename, s_lineno)
del self.known_types[s]
def visit_struct(self, struct):
if struct.tag in self.structs:
return
self.structs.add(struct.tag)
base = {True: 'Union', False: 'Structure'}[struct.is_union]
print >> self.file, 'class struct_%s(%s):' % (struct.tag, base)
print >> self.file, ' __slots__ = ['
if not struct.opaque:
for m in struct.members:
print >> self.file, " '%s'," % m[0]
print >> self.file, ' ]'
# Set fields after completing class, so incomplete structs can be
# referenced within struct.
for name, typ in struct.members:
self.emit_type(typ)
print >> self.file, 'struct_%s._fields_ = [' % struct.tag
if struct.opaque:
print >> self.file, " ('_opaque_struct', c_int)"
self.structs.remove(struct.tag)
else:
for m in struct.members:
print >> self.file, " ('%s', %s)," % (m[0], m[1])
print >> self.file, ']'
print >> self.file
def visit_enum(self, enum):
if enum.tag in self.enums:
return
self.enums.add(enum.tag)
print >> self.file, 'enum_%s = c_int' % enum.tag
for name, value in enum.enumerators:
self.all_names.append(name)
print >> self.file, '%s = %d' % (name, value)
def handle_ctypes_function(self, name, restype, argtypes, filename, lineno):
if self.does_emit(name, filename):
# Also emit any types this func requires that haven't yet been
# written.
self.emit_type(restype)
for a in argtypes:
self.emit_type(a)
self.all_names.append(name)
print >> self.file, '# %s:%d' % (filename, lineno)
print >> self.file, '%s = _lib.%s' % (name, name)
print >> self.file, '%s.restype = %s' % (name, str(restype))
print >> self.file, '%s.argtypes = [%s]' % \
(name, ', '.join([str(a) for a in argtypes]))
print >> self.file
def handle_ctypes_variable(self, name, ctype, filename, lineno):
# This doesn't work.
#self.all_names.append(name)
#print >> self.file, '%s = %s.indll(_lib, %r)' % \
# (name, str(ctype), name)
pass
def main(*argv):
import optparse
import sys
import os.path
usage = 'usage: %prog [options] <header.h>'
op = optparse.OptionParser(usage=usage)
op.add_option('-o', '--output', dest='output',
help='write wrapper to FILE', metavar='FILE')
op.add_option('-l', '--library', dest='library',
help='link to LIBRARY', metavar='LIBRARY')
op.add_option('-D', '--define', dest='defines', default=[],
help='define token NAME=VALUE', action='append')
op.add_option('-i', '--include-file', action='append', dest='include_files',
help='assume FILE is iincluded', metavar='FILE',
default=[])
op.add_option('-I', '--include-dir', action='append', dest='include_dirs',
help='add DIR to include search path', metavar='DIR',
default=[])
op.add_option('-m', '--link-module', action='append', dest='link_modules',
help='use symbols from MODULE', metavar='MODULE',
default=[])
op.add_option('-a', '--all-headers', action='store_true',
dest='all_headers',
help='include symbols from all headers', default=False)
(options, args) = op.parse_args(list(argv[1:]))
if len(args) < 1:
print >> sys.stderr, 'No header files specified.'
sys.exit(1)
headers = args
if options.library is None:
options.library = os.path.splitext(headers[0])[0]
if options.output is None:
options.output = '%s.py' % options.library
wrapper = CtypesWrapper()
wrapper.begin_output(open(options.output, 'w'),
library=options.library,
emit_filenames=headers,
link_modules=options.link_modules,
all_headers=options.all_headers)
wrapper.preprocessor_parser.include_path += options.include_dirs
for define in options.defines:
name, value = define.split('=')
wrapper.preprocessor_parser.define(name, value)
for file in options.include_files:
wrapper.wrap(file)
for header in headers:
wrapper.wrap(header)
wrapper.end_output()
print 'Wrapped to %s' % options.output
if __name__ == '__main__':
main(*sys.argv)
| Python |
#-----------------------------------------------------------------------------
# ply: lex.py
#
# Author: David M. Beazley (dave@dabeaz.com)
# Modification for pyglet by Alex Holkner (alex.holkner@gmail.com)
#
# Copyright (C) 2001-2006, David M. Beazley
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See the file LICENSE for a complete copy of the LGPL.
#-----------------------------------------------------------------------------
__version__ = "2.2"
import re, sys, types
# Regular expression used to match valid token names
_is_identifier = re.compile(r'^[a-zA-Z0-9_]+$')
# Available instance types. This is used when lexers are defined by a class.
# It's a little funky because I want to preserve backwards compatibility
# with Python 2.0 where types.ObjectType is undefined.
try:
_INSTANCETYPE = (types.InstanceType, types.ObjectType)
except AttributeError:
_INSTANCETYPE = types.InstanceType
class object: pass # Note: needed if no new-style classes present
# Exception thrown when invalid token encountered and no default error
# handler is defined.
class LexError(Exception):
def __init__(self,message,s):
self.args = (message,)
self.text = s
# Token class
class LexToken(object):
def __str__(self):
return "LexToken(%s,%r,%d,%d)" % (self.type,self.value,self.lineno,self.lexpos)
def __repr__(self):
return str(self)
def skip(self,n):
self.lexer.skip(n)
# -----------------------------------------------------------------------------
# Lexer class
#
# This class encapsulates all of the methods and data associated with a lexer.
#
# input() - Store a new string in the lexer
# token() - Get the next token
# -----------------------------------------------------------------------------
class Lexer:
def __init__(self):
self.lexre = None # Master regular expression. This is a list of
# tuples (re,findex) where re is a compiled
# regular expression and findex is a list
# mapping regex group numbers to rules
self.lexretext = None # Current regular expression strings
self.lexstatere = {} # Dictionary mapping lexer states to master regexs
self.lexstateretext = {} # Dictionary mapping lexer states to regex strings
self.lexstate = "INITIAL" # Current lexer state
self.lexstatestack = [] # Stack of lexer states
self.lexstateinfo = None # State information
self.lexstateignore = {} # Dictionary of ignored characters for each state
self.lexstateerrorf = {} # Dictionary of error functions for each state
self.lexreflags = 0 # Optional re compile flags
self.lexdata = None # Actual input data (as a string)
self.lexpos = 0 # Current position in input text
self.lexlen = 0 # Length of the input text
self.lexerrorf = None # Error rule (if any)
self.lextokens = None # List of valid tokens
self.lexignore = "" # Ignored characters
self.lexliterals = "" # Literal characters that can be passed through
self.lexmodule = None # Module
self.lineno = 1 # Current line number
self.lexdebug = 0 # Debugging mode
self.lexoptimize = 0 # Optimized mode
def clone(self,object=None):
c = Lexer()
c.lexstatere = self.lexstatere
c.lexstateinfo = self.lexstateinfo
c.lexstateretext = self.lexstateretext
c.lexstate = self.lexstate
c.lexstatestack = self.lexstatestack
c.lexstateignore = self.lexstateignore
c.lexstateerrorf = self.lexstateerrorf
c.lexreflags = self.lexreflags
c.lexdata = self.lexdata
c.lexpos = self.lexpos
c.lexlen = self.lexlen
c.lextokens = self.lextokens
c.lexdebug = self.lexdebug
c.lineno = self.lineno
c.lexoptimize = self.lexoptimize
c.lexliterals = self.lexliterals
c.lexmodule = self.lexmodule
# If the object parameter has been supplied, it means we are attaching the
# lexer to a new object. In this case, we have to rebind all methods in
# the lexstatere and lexstateerrorf tables.
if object:
newtab = { }
for key, ritem in self.lexstatere.items():
newre = []
for cre, findex in ritem:
newfindex = []
for f in findex:
if not f or not f[0]:
newfindex.append(f)
continue
newfindex.append((getattr(object,f[0].__name__),f[1]))
newre.append((cre,newfindex))
newtab[key] = newre
c.lexstatere = newtab
c.lexstateerrorf = { }
for key, ef in self.lexstateerrorf.items():
c.lexstateerrorf[key] = getattr(object,ef.__name__)
c.lexmodule = object
# Set up other attributes
c.begin(c.lexstate)
return c
# ------------------------------------------------------------
# writetab() - Write lexer information to a table file
# ------------------------------------------------------------
def writetab(self,tabfile):
tf = open(tabfile+".py","w")
tf.write("# %s.py. This file automatically created by PLY (version %s). Don't edit!\n" % (tabfile,__version__))
tf.write("_lextokens = %s\n" % repr(self.lextokens))
tf.write("_lexreflags = %s\n" % repr(self.lexreflags))
tf.write("_lexliterals = %s\n" % repr(self.lexliterals))
tf.write("_lexstateinfo = %s\n" % repr(self.lexstateinfo))
tabre = { }
for key, lre in self.lexstatere.items():
titem = []
for i in range(len(lre)):
titem.append((self.lexstateretext[key][i],_funcs_to_names(lre[i][1])))
tabre[key] = titem
tf.write("_lexstatere = %s\n" % repr(tabre))
tf.write("_lexstateignore = %s\n" % repr(self.lexstateignore))
taberr = { }
for key, ef in self.lexstateerrorf.items():
if ef:
taberr[key] = ef.__name__
else:
taberr[key] = None
tf.write("_lexstateerrorf = %s\n" % repr(taberr))
tf.close()
# ------------------------------------------------------------
# readtab() - Read lexer information from a tab file
# ------------------------------------------------------------
def readtab(self,tabfile,fdict):
exec "import %s as lextab" % tabfile
self.lextokens = lextab._lextokens
self.lexreflags = lextab._lexreflags
self.lexliterals = lextab._lexliterals
self.lexstateinfo = lextab._lexstateinfo
self.lexstateignore = lextab._lexstateignore
self.lexstatere = { }
self.lexstateretext = { }
for key,lre in lextab._lexstatere.items():
titem = []
txtitem = []
for i in range(len(lre)):
titem.append((re.compile(lre[i][0],lextab._lexreflags),_names_to_funcs(lre[i][1],fdict)))
txtitem.append(lre[i][0])
self.lexstatere[key] = titem
self.lexstateretext[key] = txtitem
self.lexstateerrorf = { }
for key,ef in lextab._lexstateerrorf.items():
self.lexstateerrorf[key] = fdict[ef]
self.begin('INITIAL')
# ------------------------------------------------------------
# input() - Push a new string into the lexer
# ------------------------------------------------------------
def input(self,s):
if not (isinstance(s,types.StringType) or isinstance(s,types.UnicodeType)):
raise ValueError, "Expected a string"
self.lexdata = s
self.lexpos = 0
self.lexlen = len(s)
# ------------------------------------------------------------
# begin() - Changes the lexing state
# ------------------------------------------------------------
def begin(self,state):
if not self.lexstatere.has_key(state):
raise ValueError, "Undefined state"
self.lexre = self.lexstatere[state]
self.lexretext = self.lexstateretext[state]
self.lexignore = self.lexstateignore.get(state,"")
self.lexerrorf = self.lexstateerrorf.get(state,None)
self.lexstate = state
# ------------------------------------------------------------
# push_state() - Changes the lexing state and saves old on stack
# ------------------------------------------------------------
def push_state(self,state):
self.lexstatestack.append(self.lexstate)
self.begin(state)
# ------------------------------------------------------------
# pop_state() - Restores the previous state
# ------------------------------------------------------------
def pop_state(self):
self.begin(self.lexstatestack.pop())
# ------------------------------------------------------------
# current_state() - Returns the current lexing state
# ------------------------------------------------------------
def current_state(self):
return self.lexstate
# ------------------------------------------------------------
# skip() - Skip ahead n characters
# ------------------------------------------------------------
def skip(self,n):
self.lexpos += n
# ------------------------------------------------------------
# token() - Return the next token from the Lexer
#
# Note: This function has been carefully implemented to be as fast
# as possible. Don't make changes unless you really know what
# you are doing
# ------------------------------------------------------------
def token(self):
# Make local copies of frequently referenced attributes
lexpos = self.lexpos
lexlen = self.lexlen
lexignore = self.lexignore
lexdata = self.lexdata
while lexpos < lexlen:
# This code provides some short-circuit code for whitespace, tabs, and other ignored characters
if lexdata[lexpos] in lexignore:
lexpos += 1
continue
# Look for a regular expression match
for lexre,lexindexfunc in self.lexre:
m = lexre.match(lexdata,lexpos)
if not m: continue
# Set last match in lexer so that rules can access it if they want
self.lexmatch = m
# Create a token for return
tok = LexToken()
tok.value = m.group()
tok.lineno = self.lineno
tok.lexpos = lexpos
tok.lexer = self
lexpos = m.end()
i = m.lastindex
func,tok.type = lexindexfunc[i]
self.lexpos = lexpos
if not func:
# If no token type was set, it's an ignored token
if tok.type: return tok
break
# if func not callable, it means it's an ignored token
if not callable(func):
break
# If token is processed by a function, call it
newtok = func(tok)
# Every function must return a token, if nothing, we just move to next token
if not newtok:
lexpos = self.lexpos # This is here in case user has updated lexpos.
# Added for pyglet/tools/wrapper/cparser.py by Alex
# Holkner on 20/Jan/2007
lexdata = self.lexdata
break
# Verify type of the token. If not in the token map, raise an error
if not self.lexoptimize:
# Allow any single-character literal also for
# pyglet/tools/wrapper/cparser.py by Alex Holkner on
# 20/Jan/2007
if not self.lextokens.has_key(newtok.type) and len(newtok.type) > 1:
raise LexError, ("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
func.func_code.co_filename, func.func_code.co_firstlineno,
func.__name__, newtok.type),lexdata[lexpos:])
return newtok
else:
# No match, see if in literals
if lexdata[lexpos] in self.lexliterals:
tok = LexToken()
tok.value = lexdata[lexpos]
tok.lineno = self.lineno
tok.lexer = self
tok.type = tok.value
tok.lexpos = lexpos
self.lexpos = lexpos + 1
return tok
# No match. Call t_error() if defined.
if self.lexerrorf:
tok = LexToken()
tok.value = self.lexdata[lexpos:]
tok.lineno = self.lineno
tok.type = "error"
tok.lexer = self
tok.lexpos = lexpos
self.lexpos = lexpos
newtok = self.lexerrorf(tok)
if lexpos == self.lexpos:
# Error method didn't change text position at all. This is an error.
raise LexError, ("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
lexpos = self.lexpos
if not newtok: continue
return newtok
self.lexpos = lexpos
raise LexError, ("Illegal character '%s' at index %d" % (lexdata[lexpos],lexpos), lexdata[lexpos:])
self.lexpos = lexpos + 1
if self.lexdata is None:
raise RuntimeError, "No input string given with input()"
return None
# -----------------------------------------------------------------------------
# _validate_file()
#
# This checks to see if there are duplicated t_rulename() functions or strings
# in the parser input file. This is done using a simple regular expression
# match on each line in the filename.
# -----------------------------------------------------------------------------
def _validate_file(filename):
import os.path
base,ext = os.path.splitext(filename)
if ext != '.py': return 1 # No idea what the file is. Return OK
try:
f = open(filename)
lines = f.readlines()
f.close()
except IOError:
return 1 # Oh well
fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(')
sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=')
counthash = { }
linen = 1
noerror = 1
for l in lines:
m = fre.match(l)
if not m:
m = sre.match(l)
if m:
name = m.group(1)
prev = counthash.get(name)
if not prev:
counthash[name] = linen
else:
print "%s:%d: Rule %s redefined. Previously defined on line %d" % (filename,linen,name,prev)
noerror = 0
linen += 1
return noerror
# -----------------------------------------------------------------------------
# _funcs_to_names()
#
# Given a list of regular expression functions, this converts it to a list
# suitable for output to a table file
# -----------------------------------------------------------------------------
def _funcs_to_names(funclist):
result = []
for f in funclist:
if f and f[0]:
result.append((f[0].__name__,f[1]))
else:
result.append(f)
return result
# -----------------------------------------------------------------------------
# _names_to_funcs()
#
# Given a list of regular expression function names, this converts it back to
# functions.
# -----------------------------------------------------------------------------
def _names_to_funcs(namelist,fdict):
result = []
for n in namelist:
if n and n[0]:
result.append((fdict[n[0]],n[1]))
else:
result.append(n)
return result
# -----------------------------------------------------------------------------
# _form_master_re()
#
# This function takes a list of all of the regex components and attempts to
# form the master regular expression. Given limitations in the Python re
# module, it may be necessary to break the master regex into separate expressions.
# -----------------------------------------------------------------------------
def _form_master_re(relist,reflags,ldict):
if not relist: return []
regex = "|".join(relist)
try:
lexre = re.compile(regex,re.VERBOSE | reflags)
# Build the index to function map for the matching engine
lexindexfunc = [ None ] * (max(lexre.groupindex.values())+1)
for f,i in lexre.groupindex.items():
handle = ldict.get(f,None)
if type(handle) in (types.FunctionType, types.MethodType):
lexindexfunc[i] = (handle,handle.__name__[2:])
elif handle is not None:
# If rule was specified as a string, we build an anonymous
# callback function to carry out the action
if f.find("ignore_") > 0:
lexindexfunc[i] = (None,None)
print "IGNORE", f
else:
lexindexfunc[i] = (None, f[2:])
return [(lexre,lexindexfunc)],[regex]
except Exception,e:
m = int(len(relist)/2)
if m == 0: m = 1
llist, lre = _form_master_re(relist[:m],reflags,ldict)
rlist, rre = _form_master_re(relist[m:],reflags,ldict)
return llist+rlist, lre+rre
# -----------------------------------------------------------------------------
# def _statetoken(s,names)
#
# Given a declaration name s of the form "t_" and a dictionary whose keys are
# state names, this function returns a tuple (states,tokenname) where states
# is a tuple of state names and tokenname is the name of the token. For example,
# calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM')
# -----------------------------------------------------------------------------
def _statetoken(s,names):
nonstate = 1
parts = s.split("_")
for i in range(1,len(parts)):
if not names.has_key(parts[i]) and parts[i] != 'ANY': break
if i > 1:
states = tuple(parts[1:i])
else:
states = ('INITIAL',)
if 'ANY' in states:
states = tuple(names.keys())
tokenname = "_".join(parts[i:])
return (states,tokenname)
# -----------------------------------------------------------------------------
# lex(module)
#
# Build all of the regular expression rules from definitions in the supplied module
# -----------------------------------------------------------------------------
# cls added for pyglet/tools/wrapper/cparser.py by Alex Holkner on 22/Jan/2007
def lex(module=None,object=None,debug=0,optimize=0,lextab="lextab",reflags=0,nowarn=0,cls=Lexer):
global lexer
ldict = None
stateinfo = { 'INITIAL' : 'inclusive'}
error = 0
files = { }
lexobj = cls()
lexobj.lexdebug = debug
lexobj.lexoptimize = optimize
global token,input
if nowarn: warn = 0
else: warn = 1
if object: module = object
if module:
# User supplied a module object.
if isinstance(module, types.ModuleType):
ldict = module.__dict__
elif isinstance(module, _INSTANCETYPE):
_items = [(k,getattr(module,k)) for k in dir(module)]
ldict = { }
for (i,v) in _items:
ldict[i] = v
else:
raise ValueError,"Expected a module or instance"
lexobj.lexmodule = module
else:
# No module given. We might be able to get information from the caller.
try:
raise RuntimeError
except RuntimeError:
e,b,t = sys.exc_info()
f = t.tb_frame
f = f.f_back # Walk out to our calling function
ldict = f.f_globals # Grab its globals dictionary
if optimize and lextab:
try:
lexobj.readtab(lextab,ldict)
token = lexobj.token
input = lexobj.input
lexer = lexobj
return lexobj
except ImportError:
pass
# Get the tokens, states, and literals variables (if any)
if (module and isinstance(module,_INSTANCETYPE)):
tokens = getattr(module,"tokens",None)
states = getattr(module,"states",None)
literals = getattr(module,"literals","")
else:
tokens = ldict.get("tokens",None)
states = ldict.get("states",None)
literals = ldict.get("literals","")
if not tokens:
raise SyntaxError,"lex: module does not define 'tokens'"
if not (isinstance(tokens,types.ListType) or isinstance(tokens,types.TupleType)):
raise SyntaxError,"lex: tokens must be a list or tuple."
# Build a dictionary of valid token names
lexobj.lextokens = { }
if not optimize:
for n in tokens:
if not _is_identifier.match(n):
print "lex: Bad token name '%s'" % n
error = 1
if warn and lexobj.lextokens.has_key(n):
print "lex: Warning. Token '%s' multiply defined." % n
lexobj.lextokens[n] = None
else:
for n in tokens: lexobj.lextokens[n] = None
if debug:
print "lex: tokens = '%s'" % lexobj.lextokens.keys()
try:
for c in literals:
if not (isinstance(c,types.StringType) or isinstance(c,types.UnicodeType)) or len(c) > 1:
print "lex: Invalid literal %s. Must be a single character" % repr(c)
error = 1
continue
except TypeError:
print "lex: Invalid literals specification. literals must be a sequence of characters."
error = 1
lexobj.lexliterals = literals
# Build statemap
if states:
if not (isinstance(states,types.TupleType) or isinstance(states,types.ListType)):
print "lex: states must be defined as a tuple or list."
error = 1
else:
for s in states:
if not isinstance(s,types.TupleType) or len(s) != 2:
print "lex: invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')" % repr(s)
error = 1
continue
name, statetype = s
if not isinstance(name,types.StringType):
print "lex: state name %s must be a string" % repr(name)
error = 1
continue
if not (statetype == 'inclusive' or statetype == 'exclusive'):
print "lex: state type for state %s must be 'inclusive' or 'exclusive'" % name
error = 1
continue
if stateinfo.has_key(name):
print "lex: state '%s' already defined." % name
error = 1
continue
stateinfo[name] = statetype
# Get a list of symbols with the t_ or s_ prefix
tsymbols = [f for f in ldict.keys() if f[:2] == 't_' ]
# Now build up a list of functions and a list of strings
funcsym = { } # Symbols defined as functions
strsym = { } # Symbols defined as strings
toknames = { } # Mapping of symbols to token names
for s in stateinfo.keys():
funcsym[s] = []
strsym[s] = []
ignore = { } # Ignore strings by state
errorf = { } # Error functions by state
if len(tsymbols) == 0:
raise SyntaxError,"lex: no rules of the form t_rulename are defined."
for f in tsymbols:
t = ldict[f]
states, tokname = _statetoken(f,stateinfo)
toknames[f] = tokname
if callable(t):
for s in states: funcsym[s].append((f,t))
elif (isinstance(t, types.StringType) or isinstance(t,types.UnicodeType)):
for s in states: strsym[s].append((f,t))
else:
print "lex: %s not defined as a function or string" % f
error = 1
# Sort the functions by line number
for f in funcsym.values():
f.sort(lambda x,y: cmp(x[1].func_code.co_firstlineno,y[1].func_code.co_firstlineno))
# Sort the strings by regular expression length
for s in strsym.values():
s.sort(lambda x,y: (len(x[1]) < len(y[1])) - (len(x[1]) > len(y[1])))
regexs = { }
# Build the master regular expressions
for state in stateinfo.keys():
regex_list = []
# Add rules defined by functions first
for fname, f in funcsym[state]:
line = f.func_code.co_firstlineno
file = f.func_code.co_filename
files[file] = None
tokname = toknames[fname]
ismethod = isinstance(f, types.MethodType)
if not optimize:
nargs = f.func_code.co_argcount
if ismethod:
reqargs = 2
else:
reqargs = 1
if nargs > reqargs:
print "%s:%d: Rule '%s' has too many arguments." % (file,line,f.__name__)
error = 1
continue
if nargs < reqargs:
print "%s:%d: Rule '%s' requires an argument." % (file,line,f.__name__)
error = 1
continue
if tokname == 'ignore':
print "%s:%d: Rule '%s' must be defined as a string." % (file,line,f.__name__)
error = 1
continue
if tokname == 'error':
errorf[state] = f
continue
if f.__doc__:
if not optimize:
try:
c = re.compile("(?P<%s>%s)" % (f.__name__,f.__doc__), re.VERBOSE | reflags)
if c.match(""):
print "%s:%d: Regular expression for rule '%s' matches empty string." % (file,line,f.__name__)
error = 1
continue
except re.error,e:
print "%s:%d: Invalid regular expression for rule '%s'. %s" % (file,line,f.__name__,e)
if '#' in f.__doc__:
print "%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'." % (file,line, f.__name__)
error = 1
continue
if debug:
print "lex: Adding rule %s -> '%s' (state '%s')" % (f.__name__,f.__doc__, state)
# Okay. The regular expression seemed okay. Let's append it to the master regular
# expression we're building
regex_list.append("(?P<%s>%s)" % (f.__name__,f.__doc__))
else:
print "%s:%d: No regular expression defined for rule '%s'" % (file,line,f.__name__)
# Now add all of the simple rules
for name,r in strsym[state]:
tokname = toknames[name]
if tokname == 'ignore':
ignore[state] = r
continue
if not optimize:
if tokname == 'error':
raise SyntaxError,"lex: Rule '%s' must be defined as a function" % name
error = 1
continue
if not lexobj.lextokens.has_key(tokname) and tokname.find("ignore_") < 0:
print "lex: Rule '%s' defined for an unspecified token %s." % (name,tokname)
error = 1
continue
try:
c = re.compile("(?P<%s>%s)" % (name,r),re.VERBOSE | reflags)
if (c.match("")):
print "lex: Regular expression for rule '%s' matches empty string." % name
error = 1
continue
except re.error,e:
print "lex: Invalid regular expression for rule '%s'. %s" % (name,e)
if '#' in r:
print "lex: Make sure '#' in rule '%s' is escaped with '\\#'." % name
error = 1
continue
if debug:
print "lex: Adding rule %s -> '%s' (state '%s')" % (name,r,state)
regex_list.append("(?P<%s>%s)" % (name,r))
if not regex_list:
print "lex: No rules defined for state '%s'" % state
error = 1
regexs[state] = regex_list
if not optimize:
for f in files.keys():
if not _validate_file(f):
error = 1
if error:
raise SyntaxError,"lex: Unable to build lexer."
# From this point forward, we're reasonably confident that we can build the lexer.
# No more errors will be generated, but there might be some warning messages.
# Build the master regular expressions
for state in regexs.keys():
lexre, re_text = _form_master_re(regexs[state],reflags,ldict)
lexobj.lexstatere[state] = lexre
lexobj.lexstateretext[state] = re_text
if debug:
for i in range(len(re_text)):
print "lex: state '%s'. regex[%d] = '%s'" % (state, i, re_text[i])
# For inclusive states, we need to add the INITIAL state
for state,type in stateinfo.items():
if state != "INITIAL" and type == 'inclusive':
lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
lexobj.lexstateinfo = stateinfo
lexobj.lexre = lexobj.lexstatere["INITIAL"]
lexobj.lexretext = lexobj.lexstateretext["INITIAL"]
# Set up ignore variables
lexobj.lexstateignore = ignore
lexobj.lexignore = lexobj.lexstateignore.get("INITIAL","")
# Set up error functions
lexobj.lexstateerrorf = errorf
lexobj.lexerrorf = errorf.get("INITIAL",None)
if warn and not lexobj.lexerrorf:
print "lex: Warning. no t_error rule is defined."
# Check state information for ignore and error rules
for s,stype in stateinfo.items():
if stype == 'exclusive':
if warn and not errorf.has_key(s):
print "lex: Warning. no error rule is defined for exclusive state '%s'" % s
if warn and not ignore.has_key(s) and lexobj.lexignore:
print "lex: Warning. no ignore rule is defined for exclusive state '%s'" % s
elif stype == 'inclusive':
if not errorf.has_key(s):
errorf[s] = errorf.get("INITIAL",None)
if not ignore.has_key(s):
ignore[s] = ignore.get("INITIAL","")
# Create global versions of the token() and input() functions
token = lexobj.token
input = lexobj.input
lexer = lexobj
# If in optimize mode, we write the lextab
if lextab and optimize:
lexobj.writetab(lextab)
return lexobj
# -----------------------------------------------------------------------------
# runmain()
#
# This runs the lexer as a main program
# -----------------------------------------------------------------------------
def runmain(lexer=None,data=None):
if not data:
try:
filename = sys.argv[1]
f = open(filename)
data = f.read()
f.close()
except IndexError:
print "Reading from standard input (type EOF to end):"
data = sys.stdin.read()
if lexer:
_input = lexer.input
else:
_input = input
_input(data)
if lexer:
_token = lexer.token
else:
_token = token
while 1:
tok = _token()
if not tok: break
print "(%s,%r,%d,%d)" % (tok.type, tok.value, tok.lineno,tok.lexpos)
# -----------------------------------------------------------------------------
# @TOKEN(regex)
#
# This decorator function can be used to set the regex expression on a function
# when its docstring might need to be set in an alternative way
# -----------------------------------------------------------------------------
def TOKEN(r):
def set_doc(f):
f.__doc__ = r
return f
return set_doc
# Alternative spelling of the TOKEN decorator
Token = TOKEN
| Python |
#-----------------------------------------------------------------------------
# ply: yacc.py
#
# Author(s): David M. Beazley (dave@dabeaz.com)
# Modifications for pyglet by Alex Holkner (alex.holkner@gmail.com) (<ah>)
#
# Copyright (C) 2001-2006, David M. Beazley
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# See the file COPYING for a complete copy of the LGPL.
#
#
# This implements an LR parser that is constructed from grammar rules defined
# as Python functions. The grammer is specified by supplying the BNF inside
# Python documentation strings. The inspiration for this technique was borrowed
# from John Aycock's Spark parsing system. PLY might be viewed as cross between
# Spark and the GNU bison utility.
#
# The current implementation is only somewhat object-oriented. The
# LR parser itself is defined in terms of an object (which allows multiple
# parsers to co-exist). However, most of the variables used during table
# construction are defined in terms of global variables. Users shouldn't
# notice unless they are trying to define multiple parsers at the same
# time using threads (in which case they should have their head examined).
#
# This implementation supports both SLR and LALR(1) parsing. LALR(1)
# support was originally implemented by Elias Ioup (ezioup@alumni.uchicago.edu),
# using the algorithm found in Aho, Sethi, and Ullman "Compilers: Principles,
# Techniques, and Tools" (The Dragon Book). LALR(1) has since been replaced
# by the more efficient DeRemer and Pennello algorithm.
#
# :::::::: WARNING :::::::
#
# Construction of LR parsing tables is fairly complicated and expensive.
# To make this module run fast, a *LOT* of work has been put into
# optimization---often at the expensive of readability and what might
# consider to be good Python "coding style." Modify the code at your
# own risk!
# ----------------------------------------------------------------------------
__version__ = "2.2"
#-----------------------------------------------------------------------------
# === User configurable parameters ===
#
# Change these to modify the default behavior of yacc (if you wish)
#-----------------------------------------------------------------------------
yaccdebug = 1 # Debugging mode. If set, yacc generates a
# a 'parser.out' file in the current directory
debug_file = 'parser.out' # Default name of the debugging file
tab_module = 'parsetab' # Default name of the table module
default_lr = 'LALR' # Default LR table generation method
error_count = 3 # Number of symbols that must be shifted to leave recovery mode
import re, types, sys, cStringIO, md5, os.path
# Exception raised for yacc-related errors
class YaccError(Exception): pass
#-----------------------------------------------------------------------------
# === LR Parsing Engine ===
#
# The following classes are used for the LR parser itself. These are not
# used during table construction and are independent of the actual LR
# table generation algorithm
#-----------------------------------------------------------------------------
# This class is used to hold non-terminal grammar symbols during parsing.
# It normally has the following attributes set:
# .type = Grammar symbol type
# .value = Symbol value
# .lineno = Starting line number
# .endlineno = Ending line number (optional, set automatically)
# .lexpos = Starting lex position
# .endlexpos = Ending lex position (optional, set automatically)
class YaccSymbol:
filename = '' # <ah>
def __str__(self): return self.type
def __repr__(self): return str(self)
# This class is a wrapper around the objects actually passed to each
# grammar rule. Index lookup and assignment actually assign the
# .value attribute of the underlying YaccSymbol object.
# The lineno() method returns the line number of a given
# item (or 0 if not defined). The linespan() method returns
# a tuple of (startline,endline) representing the range of lines
# for a symbol. The lexspan() method returns a tuple (lexpos,endlexpos)
# representing the range of positional information for a symbol.
class YaccProduction:
def __init__(self,s,stack=None):
self.slice = s
self.pbstack = []
self.stack = stack
def __getitem__(self,n):
if type(n) == types.IntType:
if n >= 0: return self.slice[n].value
else: return self.stack[n].value
else:
return [s.value for s in self.slice[n.start:n.stop:n.step]]
def __setitem__(self,n,v):
self.slice[n].value = v
def __len__(self):
return len(self.slice)
def lineno(self,n):
return getattr(self.slice[n],"lineno",0)
def linespan(self,n):
startline = getattr(self.slice[n],"lineno",0)
endline = getattr(self.slice[n],"endlineno",startline)
return startline,endline
def lexpos(self,n):
return getattr(self.slice[n],"lexpos",0)
def lexspan(self,n):
startpos = getattr(self.slice[n],"lexpos",0)
endpos = getattr(self.slice[n],"endlexpos",startpos)
return startpos,endpos
def pushback(self,n):
if n <= 0:
raise ValueError, "Expected a positive value"
if n > (len(self.slice)-1):
raise ValueError, "Can't push %d tokens. Only %d are available." % (n,len(self.slice)-1)
for i in range(0,n):
self.pbstack.append(self.slice[-i-1])
# The LR Parsing engine. This is defined as a class so that multiple parsers
# can exist in the same process. A user never instantiates this directly.
# Instead, the global yacc() function should be used to create a suitable Parser
# object.
class Parser:
# <ah> Remove magic (use ParserPrototype)
def __init__(self):
# Reset internal state
self.productions = None # List of productions
self.errorfunc = None # Error handling function
self.action = { } # LR Action table
self.goto = { } # LR goto table
self.require = { } # Attribute require table
self.method = "Unknown LR" # Table construction method used
# <ah> 25 Jan 2007
self.statestackstack = []
self.symstackstack = []
def errok(self):
self.errorcount = 0
def restart(self):
del self.statestack[:]
del self.symstack[:]
sym = YaccSymbol()
sym.type = '$end'
self.symstack.append(sym)
self.statestack.append(0)
def push_state(self):
'''Save parser state and restart it.'''
# <ah> 25 Jan 2007
self.statestackstack.append(self.statestack[:])
self.symstackstack.append(self.symstack[:])
self.restart()
def pop_state(self):
'''Restore saved parser state.'''
# <ah> 25 Jan 2007
self.statestack[:] = self.statestackstack.pop()
self.symstack[:] = self.symstackstack.pop()
def parse(self,input=None,lexer=None,debug=0):
lookahead = None # Current lookahead symbol
lookaheadstack = [ ] # Stack of lookahead symbols
actions = self.action # Local reference to action table
goto = self.goto # Local reference to goto table
prod = self.productions # Local reference to production list
pslice = YaccProduction(None) # Production object passed to grammar rules
pslice.parser = self # Parser object
self.errorcount = 0 # Used during error recovery
# If no lexer was given, we will try to use the lex module
if not lexer:
import lex
lexer = lex.lexer
pslice.lexer = lexer
# If input was supplied, pass to lexer
if input:
lexer.input(input)
# Tokenize function
get_token = lexer.token
statestack = [ ] # Stack of parsing states
self.statestack = statestack
symstack = [ ] # Stack of grammar symbols
self.symstack = symstack
pslice.stack = symstack # Put in the production
errtoken = None # Err token
# The start state is assumed to be (0,$end)
statestack.append(0)
sym = YaccSymbol()
sym.type = '$end'
symstack.append(sym)
while 1:
# Get the next symbol on the input. If a lookahead symbol
# is already set, we just use that. Otherwise, we'll pull
# the next token off of the lookaheadstack or from the lexer
if debug > 1:
print 'state', statestack[-1]
if not lookahead:
if not lookaheadstack:
lookahead = get_token() # Get the next token
else:
lookahead = lookaheadstack.pop()
if not lookahead:
lookahead = YaccSymbol()
lookahead.type = '$end'
if debug:
errorlead = ("%s . %s" % (" ".join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip()
# Check the action table
s = statestack[-1]
ltype = lookahead.type
t = actions.get((s,ltype),None)
if debug > 1:
print 'action', t
if t is not None:
if t > 0:
# shift a symbol on the stack
if ltype == '$end':
# Error, end of input
sys.stderr.write("yacc: Parse error. EOF\n")
return
statestack.append(t)
if debug > 1:
sys.stderr.write("%-60s shift state %s\n" % (errorlead, t))
symstack.append(lookahead)
lookahead = None
# Decrease error count on successful shift
if self.errorcount > 0:
self.errorcount -= 1
continue
if t < 0:
# reduce a symbol on the stack, emit a production
p = prod[-t]
pname = p.name
plen = p.len
# Get production function
sym = YaccSymbol()
sym.type = pname # Production name
sym.value = None
if debug > 1:
sys.stderr.write("%-60s reduce %d\n" % (errorlead, -t))
if plen:
targ = symstack[-plen-1:]
targ[0] = sym
try:
sym.lineno = targ[1].lineno
sym.filename = targ[1].filename
sym.endlineno = getattr(targ[-1],"endlineno",targ[-1].lineno)
sym.lexpos = targ[1].lexpos
sym.endlexpos = getattr(targ[-1],"endlexpos",targ[-1].lexpos)
except AttributeError:
sym.lineno = 0
del symstack[-plen:]
del statestack[-plen:]
else:
sym.lineno = 0
targ = [ sym ]
pslice.slice = targ
pslice.pbstack = []
# Call the grammar rule with our special slice object
p.func(pslice)
# If there was a pushback, put that on the stack
if pslice.pbstack:
lookaheadstack.append(lookahead)
for _t in pslice.pbstack:
lookaheadstack.append(_t)
lookahead = None
symstack.append(sym)
statestack.append(goto[statestack[-1],pname])
continue
if t == 0:
n = symstack[-1]
return getattr(n,"value",None)
sys.stderr.write(errorlead, "\n")
if t == None:
if debug:
sys.stderr.write(errorlead + "\n")
# We have some kind of parsing error here. To handle
# this, we are going to push the current token onto
# the tokenstack and replace it with an 'error' token.
# If there are any synchronization rules, they may
# catch it.
#
# In addition to pushing the error token, we call call
# the user defined p_error() function if this is the
# first syntax error. This function is only called if
# errorcount == 0.
if not self.errorcount:
self.errorcount = error_count
errtoken = lookahead
if errtoken.type == '$end':
errtoken = None # End of file!
if self.errorfunc:
global errok,token,restart
errok = self.errok # Set some special functions available in error recovery
token = get_token
restart = self.restart
tok = self.errorfunc(errtoken)
del errok, token, restart # Delete special functions
if not self.errorcount:
# User must have done some kind of panic
# mode recovery on their own. The
# returned token is the next lookahead
lookahead = tok
errtoken = None
continue
else:
if errtoken:
if hasattr(errtoken,"lineno"): lineno = lookahead.lineno
else: lineno = 0
if lineno:
sys.stderr.write("yacc: Syntax error at line %d, token=%s\n" % (lineno, errtoken.type))
else:
sys.stderr.write("yacc: Syntax error, token=%s" % errtoken.type)
else:
sys.stderr.write("yacc: Parse error in input. EOF\n")
return
else:
self.errorcount = error_count
# case 1: the statestack only has 1 entry on it. If we're in this state, the
# entire parse has been rolled back and we're completely hosed. The token is
# discarded and we just keep going.
if len(statestack) <= 1 and lookahead.type != '$end':
lookahead = None
errtoken = None
# Nuke the pushback stack
del lookaheadstack[:]
continue
# case 2: the statestack has a couple of entries on it, but we're
# at the end of the file. nuke the top entry and generate an error token
# Start nuking entries on the stack
if lookahead.type == '$end':
# Whoa. We're really hosed here. Bail out
return
if lookahead.type != 'error':
sym = symstack[-1]
if sym.type == 'error':
# Hmmm. Error is on top of stack, we'll just nuke input
# symbol and continue
lookahead = None
continue
t = YaccSymbol()
t.type = 'error'
if hasattr(lookahead,"lineno"):
t.lineno = lookahead.lineno
t.value = lookahead
lookaheadstack.append(lookahead)
lookahead = t
else:
symstack.pop()
statestack.pop()
continue
# Call an error function here
raise RuntimeError, "yacc: internal parser error!!!\n"
# -----------------------------------------------------------------------------
# === Parser Construction ===
#
# The following functions and variables are used to implement the yacc() function
# itself. This is pretty hairy stuff involving lots of error checking,
# construction of LR items, kernels, and so forth. Although a lot of
# this work is done using global variables, the resulting Parser object
# is completely self contained--meaning that it is safe to repeatedly
# call yacc() with different grammars in the same application.
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# validate_file()
#
# This function checks to see if there are duplicated p_rulename() functions
# in the parser module file. Without this function, it is really easy for
# users to make mistakes by cutting and pasting code fragments (and it's a real
# bugger to try and figure out why the resulting parser doesn't work). Therefore,
# we just do a little regular expression pattern matching of def statements
# to try and detect duplicates.
# -----------------------------------------------------------------------------
def validate_file(filename):
base,ext = os.path.splitext(filename)
if ext != '.py': return 1 # No idea. Assume it's okay.
try:
f = open(filename)
lines = f.readlines()
f.close()
except IOError:
return 1 # Oh well
# Match def p_funcname(
fre = re.compile(r'\s*def\s+(p_[a-zA-Z_0-9]*)\(')
counthash = { }
linen = 1
noerror = 1
for l in lines:
m = fre.match(l)
if m:
name = m.group(1)
prev = counthash.get(name)
if not prev:
counthash[name] = linen
else:
sys.stderr.write("%s:%d: Function %s redefined. Previously defined on line %d\n" % (filename,linen,name,prev))
noerror = 0
linen += 1
return noerror
# This function looks for functions that might be grammar rules, but which don't have the proper p_suffix.
def validate_dict(d):
for n,v in d.items():
if n[0:2] == 'p_' and type(v) in (types.FunctionType, types.MethodType): continue
if n[0:2] == 't_': continue
if n[0:2] == 'p_':
sys.stderr.write("yacc: Warning. '%s' not defined as a function\n" % n)
if 1 and isinstance(v,types.FunctionType) and v.func_code.co_argcount == 1:
try:
doc = v.__doc__.split(" ")
if doc[1] == ':':
sys.stderr.write("%s:%d: Warning. Possible grammar rule '%s' defined without p_ prefix.\n" % (v.func_code.co_filename, v.func_code.co_firstlineno,n))
except StandardError:
pass
# -----------------------------------------------------------------------------
# === GRAMMAR FUNCTIONS ===
#
# The following global variables and functions are used to store, manipulate,
# and verify the grammar rules specified by the user.
# -----------------------------------------------------------------------------
# Initialize all of the global variables used during grammar construction
def initialize_vars():
global Productions, Prodnames, Prodmap, Terminals
global Nonterminals, First, Follow, Precedence, LRitems
global Errorfunc, Signature, Requires
Productions = [None] # A list of all of the productions. The first
# entry is always reserved for the purpose of
# building an augmented grammar
Prodnames = { } # A dictionary mapping the names of nonterminals to a list of all
# productions of that nonterminal.
Prodmap = { } # A dictionary that is only used to detect duplicate
# productions.
Terminals = { } # A dictionary mapping the names of terminal symbols to a
# list of the rules where they are used.
Nonterminals = { } # A dictionary mapping names of nonterminals to a list
# of rule numbers where they are used.
First = { } # A dictionary of precomputed FIRST(x) symbols
Follow = { } # A dictionary of precomputed FOLLOW(x) symbols
Precedence = { } # Precedence rules for each terminal. Contains tuples of the
# form ('right',level) or ('nonassoc', level) or ('left',level)
LRitems = [ ] # A list of all LR items for the grammar. These are the
# productions with the "dot" like E -> E . PLUS E
Errorfunc = None # User defined error handler
Signature = md5.new() # Digital signature of the grammar rules, precedence
# and other information. Used to determined when a
# parsing table needs to be regenerated.
Requires = { } # Requires list
# File objects used when creating the parser.out debugging file
global _vf, _vfc
_vf = cStringIO.StringIO()
_vfc = cStringIO.StringIO()
# -----------------------------------------------------------------------------
# class Production:
#
# This class stores the raw information about a single production or grammar rule.
# It has a few required attributes:
#
# name - Name of the production (nonterminal)
# prod - A list of symbols making up its production
# number - Production number.
#
# In addition, a few additional attributes are used to help with debugging or
# optimization of table generation.
#
# file - File where production action is defined.
# lineno - Line number where action is defined
# func - Action function
# prec - Precedence level
# lr_next - Next LR item. Example, if we are ' E -> E . PLUS E'
# then lr_next refers to 'E -> E PLUS . E'
# lr_index - LR item index (location of the ".") in the prod list.
# lookaheads - LALR lookahead symbols for this item
# len - Length of the production (number of symbols on right hand side)
# -----------------------------------------------------------------------------
class Production:
def __init__(self,**kw):
for k,v in kw.items():
setattr(self,k,v)
self.lr_index = -1
self.lr0_added = 0 # Flag indicating whether or not added to LR0 closure
self.lr1_added = 0 # Flag indicating whether or not added to LR1
self.usyms = [ ]
self.lookaheads = { }
self.lk_added = { }
self.setnumbers = [ ]
def __str__(self):
if self.prod:
s = "%s -> %s" % (self.name," ".join(self.prod))
else:
s = "%s -> <empty>" % self.name
return s
def __repr__(self):
return str(self)
# Compute lr_items from the production
def lr_item(self,n):
if n > len(self.prod): return None
p = Production()
p.name = self.name
p.prod = list(self.prod)
p.number = self.number
p.lr_index = n
p.lookaheads = { }
p.setnumbers = self.setnumbers
p.prod.insert(n,".")
p.prod = tuple(p.prod)
p.len = len(p.prod)
p.usyms = self.usyms
# Precompute list of productions immediately following
try:
p.lrafter = Prodnames[p.prod[n+1]]
except (IndexError,KeyError),e:
p.lrafter = []
try:
p.lrbefore = p.prod[n-1]
except IndexError:
p.lrbefore = None
return p
class MiniProduction:
pass
# regex matching identifiers
_is_identifier = re.compile(r'^[a-zA-Z0-9_-]+$')
# -----------------------------------------------------------------------------
# add_production()
#
# Given an action function, this function assembles a production rule.
# The production rule is assumed to be found in the function's docstring.
# This rule has the general syntax:
#
# name1 ::= production1
# | production2
# | production3
# ...
# | productionn
# name2 ::= production1
# | production2
# ...
# -----------------------------------------------------------------------------
def add_production(f,file,line,prodname,syms):
if Terminals.has_key(prodname):
sys.stderr.write("%s:%d: Illegal rule name '%s'. Already defined as a token.\n" % (file,line,prodname))
return -1
if prodname == 'error':
sys.stderr.write("%s:%d: Illegal rule name '%s'. error is a reserved word.\n" % (file,line,prodname))
return -1
if not _is_identifier.match(prodname):
sys.stderr.write("%s:%d: Illegal rule name '%s'\n" % (file,line,prodname))
return -1
for x in range(len(syms)):
s = syms[x]
if s[0] in "'\"":
try:
c = eval(s)
if (len(c) > 1):
sys.stderr.write("%s:%d: Literal token %s in rule '%s' may only be a single character\n" % (file,line,s, prodname))
return -1
if not Terminals.has_key(c):
Terminals[c] = []
syms[x] = c
continue
except SyntaxError:
pass
if not _is_identifier.match(s) and s != '%prec':
sys.stderr.write("%s:%d: Illegal name '%s' in rule '%s'\n" % (file,line,s, prodname))
return -1
# See if the rule is already in the rulemap
map = "%s -> %s" % (prodname,syms)
if Prodmap.has_key(map):
m = Prodmap[map]
sys.stderr.write("%s:%d: Duplicate rule %s.\n" % (file,line, m))
sys.stderr.write("%s:%d: Previous definition at %s:%d\n" % (file,line, m.file, m.line))
return -1
p = Production()
p.name = prodname
p.prod = syms
p.file = file
p.line = line
p.func = f
p.number = len(Productions)
Productions.append(p)
Prodmap[map] = p
if not Nonterminals.has_key(prodname):
Nonterminals[prodname] = [ ]
# Add all terminals to Terminals
i = 0
while i < len(p.prod):
t = p.prod[i]
if t == '%prec':
try:
precname = p.prod[i+1]
except IndexError:
sys.stderr.write("%s:%d: Syntax error. Nothing follows %%prec.\n" % (p.file,p.line))
return -1
prec = Precedence.get(precname,None)
if not prec:
sys.stderr.write("%s:%d: Nothing known about the precedence of '%s'\n" % (p.file,p.line,precname))
return -1
else:
p.prec = prec
del p.prod[i]
del p.prod[i]
continue
if Terminals.has_key(t):
Terminals[t].append(p.number)
# Is a terminal. We'll assign a precedence to p based on this
if not hasattr(p,"prec"):
p.prec = Precedence.get(t,('right',0))
else:
if not Nonterminals.has_key(t):
Nonterminals[t] = [ ]
Nonterminals[t].append(p.number)
i += 1
if not hasattr(p,"prec"):
p.prec = ('right',0)
# Set final length of productions
p.len = len(p.prod)
p.prod = tuple(p.prod)
# Calculate unique syms in the production
p.usyms = [ ]
for s in p.prod:
if s not in p.usyms:
p.usyms.append(s)
# Add to the global productions list
try:
Prodnames[p.name].append(p)
except KeyError:
Prodnames[p.name] = [ p ]
return 0
# Given a raw rule function, this function rips out its doc string
# and adds rules to the grammar
def add_function(f):
line = f.func_code.co_firstlineno
file = f.func_code.co_filename
error = 0
if isinstance(f,types.MethodType):
reqdargs = 2
else:
reqdargs = 1
if f.func_code.co_argcount > reqdargs:
sys.stderr.write("%s:%d: Rule '%s' has too many arguments.\n" % (file,line,f.__name__))
return -1
if f.func_code.co_argcount < reqdargs:
sys.stderr.write("%s:%d: Rule '%s' requires an argument.\n" % (file,line,f.__name__))
return -1
if f.__doc__:
# Split the doc string into lines
pstrings = f.__doc__.splitlines()
lastp = None
dline = line
for ps in pstrings:
dline += 1
p = ps.split()
if not p: continue
try:
if p[0] == '|':
# This is a continuation of a previous rule
if not lastp:
sys.stderr.write("%s:%d: Misplaced '|'.\n" % (file,dline))
return -1
prodname = lastp
if len(p) > 1:
syms = p[1:]
else:
syms = [ ]
else:
prodname = p[0]
lastp = prodname
assign = p[1]
if len(p) > 2:
syms = p[2:]
else:
syms = [ ]
if assign != ':' and assign != '::=':
sys.stderr.write("%s:%d: Syntax error. Expected ':'\n" % (file,dline))
return -1
e = add_production(f,file,dline,prodname,syms)
error += e
except StandardError:
sys.stderr.write("%s:%d: Syntax error in rule '%s'\n" % (file,dline,ps))
error -= 1
else:
sys.stderr.write("%s:%d: No documentation string specified in function '%s'\n" % (file,line,f.__name__))
return error
# Cycle checking code (Michael Dyck)
def compute_reachable():
'''
Find each symbol that can be reached from the start symbol.
Print a warning for any nonterminals that can't be reached.
(Unused terminals have already had their warning.)
'''
Reachable = { }
for s in Terminals.keys() + Nonterminals.keys():
Reachable[s] = 0
mark_reachable_from( Productions[0].prod[0], Reachable )
for s in Nonterminals.keys():
if not Reachable[s]:
sys.stderr.write("yacc: Symbol '%s' is unreachable.\n" % s)
def mark_reachable_from(s, Reachable):
'''
Mark all symbols that are reachable from symbol s.
'''
if Reachable[s]:
# We've already reached symbol s.
return
Reachable[s] = 1
for p in Prodnames.get(s,[]):
for r in p.prod:
mark_reachable_from(r, Reachable)
# -----------------------------------------------------------------------------
# compute_terminates()
#
# This function looks at the various parsing rules and tries to detect
# infinite recursion cycles (grammar rules where there is no possible way
# to derive a string of only terminals).
# -----------------------------------------------------------------------------
def compute_terminates():
'''
Raise an error for any symbols that don't terminate.
'''
Terminates = {}
# Terminals:
for t in Terminals.keys():
Terminates[t] = 1
Terminates['$end'] = 1
# Nonterminals:
# Initialize to false:
for n in Nonterminals.keys():
Terminates[n] = 0
# Then propagate termination until no change:
while 1:
some_change = 0
for (n,pl) in Prodnames.items():
# Nonterminal n terminates iff any of its productions terminates.
for p in pl:
# Production p terminates iff all of its rhs symbols terminate.
for s in p.prod:
if not Terminates[s]:
# The symbol s does not terminate,
# so production p does not terminate.
p_terminates = 0
break
else:
# didn't break from the loop,
# so every symbol s terminates
# so production p terminates.
p_terminates = 1
if p_terminates:
# symbol n terminates!
if not Terminates[n]:
Terminates[n] = 1
some_change = 1
# Don't need to consider any more productions for this n.
break
if not some_change:
break
some_error = 0
for (s,terminates) in Terminates.items():
if not terminates:
if not Prodnames.has_key(s) and not Terminals.has_key(s) and s != 'error':
# s is used-but-not-defined, and we've already warned of that,
# so it would be overkill to say that it's also non-terminating.
pass
else:
sys.stderr.write("yacc: Infinite recursion detected for symbol '%s'.\n" % s)
some_error = 1
return some_error
# -----------------------------------------------------------------------------
# verify_productions()
#
# This function examines all of the supplied rules to see if they seem valid.
# -----------------------------------------------------------------------------
def verify_productions(cycle_check=1):
error = 0
for p in Productions:
if not p: continue
for s in p.prod:
if not Prodnames.has_key(s) and not Terminals.has_key(s) and s != 'error':
sys.stderr.write("%s:%d: Symbol '%s' used, but not defined as a token or a rule.\n" % (p.file,p.line,s))
error = 1
continue
unused_tok = 0
# Now verify all of the tokens
if yaccdebug:
_vf.write("Unused terminals:\n\n")
for s,v in Terminals.items():
if s != 'error' and not v:
sys.stderr.write("yacc: Warning. Token '%s' defined, but not used.\n" % s)
if yaccdebug: _vf.write(" %s\n"% s)
unused_tok += 1
# Print out all of the productions
if yaccdebug:
_vf.write("\nGrammar\n\n")
for i in range(1,len(Productions)):
_vf.write("Rule %-5d %s\n" % (i, Productions[i]))
unused_prod = 0
# Verify the use of all productions
for s,v in Nonterminals.items():
if not v:
p = Prodnames[s][0]
sys.stderr.write("%s:%d: Warning. Rule '%s' defined, but not used.\n" % (p.file,p.line, s))
unused_prod += 1
if unused_tok == 1:
sys.stderr.write("yacc: Warning. There is 1 unused token.\n")
if unused_tok > 1:
sys.stderr.write("yacc: Warning. There are %d unused tokens.\n" % unused_tok)
if unused_prod == 1:
sys.stderr.write("yacc: Warning. There is 1 unused rule.\n")
if unused_prod > 1:
sys.stderr.write("yacc: Warning. There are %d unused rules.\n" % unused_prod)
if yaccdebug:
_vf.write("\nTerminals, with rules where they appear\n\n")
ks = Terminals.keys()
ks.sort()
for k in ks:
_vf.write("%-20s : %s\n" % (k, " ".join([str(s) for s in Terminals[k]])))
_vf.write("\nNonterminals, with rules where they appear\n\n")
ks = Nonterminals.keys()
ks.sort()
for k in ks:
_vf.write("%-20s : %s\n" % (k, " ".join([str(s) for s in Nonterminals[k]])))
if (cycle_check):
compute_reachable()
error += compute_terminates()
# error += check_cycles()
return error
# -----------------------------------------------------------------------------
# build_lritems()
#
# This function walks the list of productions and builds a complete set of the
# LR items. The LR items are stored in two ways: First, they are uniquely
# numbered and placed in the list _lritems. Second, a linked list of LR items
# is built for each production. For example:
#
# E -> E PLUS E
#
# Creates the list
#
# [E -> . E PLUS E, E -> E . PLUS E, E -> E PLUS . E, E -> E PLUS E . ]
# -----------------------------------------------------------------------------
def build_lritems():
for p in Productions:
lastlri = p
lri = p.lr_item(0)
i = 0
while 1:
lri = p.lr_item(i)
lastlri.lr_next = lri
if not lri: break
lri.lr_num = len(LRitems)
LRitems.append(lri)
lastlri = lri
i += 1
# In order for the rest of the parser generator to work, we need to
# guarantee that no more lritems are generated. Therefore, we nuke
# the p.lr_item method. (Only used in debugging)
# Production.lr_item = None
# -----------------------------------------------------------------------------
# add_precedence()
#
# Given a list of precedence rules, add to the precedence table.
# -----------------------------------------------------------------------------
def add_precedence(plist):
plevel = 0
error = 0
for p in plist:
plevel += 1
try:
prec = p[0]
terms = p[1:]
if prec != 'left' and prec != 'right' and prec != 'nonassoc':
sys.stderr.write("yacc: Invalid precedence '%s'\n" % prec)
return -1
for t in terms:
if Precedence.has_key(t):
sys.stderr.write("yacc: Precedence already specified for terminal '%s'\n" % t)
error += 1
continue
Precedence[t] = (prec,plevel)
except:
sys.stderr.write("yacc: Invalid precedence table.\n")
error += 1
return error
# -----------------------------------------------------------------------------
# augment_grammar()
#
# Compute the augmented grammar. This is just a rule S' -> start where start
# is the starting symbol.
# -----------------------------------------------------------------------------
def augment_grammar(start=None):
if not start:
start = Productions[1].name
Productions[0] = Production(name="S'",prod=[start],number=0,len=1,prec=('right',0),func=None)
Productions[0].usyms = [ start ]
Nonterminals[start].append(0)
# -------------------------------------------------------------------------
# first()
#
# Compute the value of FIRST1(beta) where beta is a tuple of symbols.
#
# During execution of compute_first1, the result may be incomplete.
# Afterward (e.g., when called from compute_follow()), it will be complete.
# -------------------------------------------------------------------------
def first(beta):
# We are computing First(x1,x2,x3,...,xn)
result = [ ]
for x in beta:
x_produces_empty = 0
# Add all the non-<empty> symbols of First[x] to the result.
for f in First[x]:
if f == '<empty>':
x_produces_empty = 1
else:
if f not in result: result.append(f)
if x_produces_empty:
# We have to consider the next x in beta,
# i.e. stay in the loop.
pass
else:
# We don't have to consider any further symbols in beta.
break
else:
# There was no 'break' from the loop,
# so x_produces_empty was true for all x in beta,
# so beta produces empty as well.
result.append('<empty>')
return result
# FOLLOW(x)
# Given a non-terminal. This function computes the set of all symbols
# that might follow it. Dragon book, p. 189.
def compute_follow(start=None):
# Add '$end' to the follow list of the start symbol
for k in Nonterminals.keys():
Follow[k] = [ ]
if not start:
start = Productions[1].name
Follow[start] = [ '$end' ]
while 1:
didadd = 0
for p in Productions[1:]:
# Here is the production set
for i in range(len(p.prod)):
B = p.prod[i]
if Nonterminals.has_key(B):
# Okay. We got a non-terminal in a production
fst = first(p.prod[i+1:])
hasempty = 0
for f in fst:
if f != '<empty>' and f not in Follow[B]:
Follow[B].append(f)
didadd = 1
if f == '<empty>':
hasempty = 1
if hasempty or i == (len(p.prod)-1):
# Add elements of follow(a) to follow(b)
for f in Follow[p.name]:
if f not in Follow[B]:
Follow[B].append(f)
didadd = 1
if not didadd: break
if 0 and yaccdebug:
_vf.write('\nFollow:\n')
for k in Nonterminals.keys():
_vf.write("%-20s : %s\n" % (k, " ".join([str(s) for s in Follow[k]])))
# -------------------------------------------------------------------------
# compute_first1()
#
# Compute the value of FIRST1(X) for all symbols
# -------------------------------------------------------------------------
def compute_first1():
# Terminals:
for t in Terminals.keys():
First[t] = [t]
First['$end'] = ['$end']
First['#'] = ['#'] # what's this for?
# Nonterminals:
# Initialize to the empty set:
for n in Nonterminals.keys():
First[n] = []
# Then propagate symbols until no change:
while 1:
some_change = 0
for n in Nonterminals.keys():
for p in Prodnames[n]:
for f in first(p.prod):
if f not in First[n]:
First[n].append( f )
some_change = 1
if not some_change:
break
if 0 and yaccdebug:
_vf.write('\nFirst:\n')
for k in Nonterminals.keys():
_vf.write("%-20s : %s\n" %
(k, " ".join([str(s) for s in First[k]])))
# -----------------------------------------------------------------------------
# === SLR Generation ===
#
# The following functions are used to construct SLR (Simple LR) parsing tables
# as described on p.221-229 of the dragon book.
# -----------------------------------------------------------------------------
# Global variables for the LR parsing engine
def lr_init_vars():
global _lr_action, _lr_goto, _lr_method
global _lr_goto_cache, _lr0_cidhash
_lr_action = { } # Action table
_lr_goto = { } # Goto table
_lr_method = "Unknown" # LR method used
_lr_goto_cache = { }
_lr0_cidhash = { }
# Compute the LR(0) closure operation on I, where I is a set of LR(0) items.
# prodlist is a list of productions.
_add_count = 0 # Counter used to detect cycles
def lr0_closure(I):
global _add_count
_add_count += 1
prodlist = Productions
# Add everything in I to J
J = I[:]
didadd = 1
while didadd:
didadd = 0
for j in J:
for x in j.lrafter:
if x.lr0_added == _add_count: continue
# Add B --> .G to J
J.append(x.lr_next)
x.lr0_added = _add_count
didadd = 1
return J
# Compute the LR(0) goto function goto(I,X) where I is a set
# of LR(0) items and X is a grammar symbol. This function is written
# in a way that guarantees uniqueness of the generated goto sets
# (i.e. the same goto set will never be returned as two different Python
# objects). With uniqueness, we can later do fast set comparisons using
# id(obj) instead of element-wise comparison.
def lr0_goto(I,x):
# First we look for a previously cached entry
g = _lr_goto_cache.get((id(I),x),None)
if g: return g
# Now we generate the goto set in a way that guarantees uniqueness
# of the result
s = _lr_goto_cache.get(x,None)
if not s:
s = { }
_lr_goto_cache[x] = s
gs = [ ]
for p in I:
n = p.lr_next
if n and n.lrbefore == x:
s1 = s.get(id(n),None)
if not s1:
s1 = { }
s[id(n)] = s1
gs.append(n)
s = s1
g = s.get('$end',None)
if not g:
if gs:
g = lr0_closure(gs)
s['$end'] = g
else:
s['$end'] = gs
_lr_goto_cache[(id(I),x)] = g
return g
_lr0_cidhash = { }
# Compute the LR(0) sets of item function
def lr0_items():
C = [ lr0_closure([Productions[0].lr_next]) ]
i = 0
for I in C:
_lr0_cidhash[id(I)] = i
i += 1
# Loop over the items in C and each grammar symbols
i = 0
while i < len(C):
I = C[i]
i += 1
# Collect all of the symbols that could possibly be in the goto(I,X) sets
asyms = { }
for ii in I:
for s in ii.usyms:
asyms[s] = None
for x in asyms.keys():
g = lr0_goto(I,x)
if not g: continue
if _lr0_cidhash.has_key(id(g)): continue
_lr0_cidhash[id(g)] = len(C)
C.append(g)
return C
# -----------------------------------------------------------------------------
# ==== LALR(1) Parsing ====
#
# LALR(1) parsing is almost exactly the same as SLR except that instead of
# relying upon Follow() sets when performing reductions, a more selective
# lookahead set that incorporates the state of the LR(0) machine is utilized.
# Thus, we mainly just have to focus on calculating the lookahead sets.
#
# The method used here is due to DeRemer and Pennelo (1982).
#
# DeRemer, F. L., and T. J. Pennelo: "Efficient Computation of LALR(1)
# Lookahead Sets", ACM Transactions on Programming Languages and Systems,
# Vol. 4, No. 4, Oct. 1982, pp. 615-649
#
# Further details can also be found in:
#
# J. Tremblay and P. Sorenson, "The Theory and Practice of Compiler Writing",
# McGraw-Hill Book Company, (1985).
#
# Note: This implementation is a complete replacement of the LALR(1)
# implementation in PLY-1.x releases. That version was based on
# a less efficient algorithm and it had bugs in its implementation.
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# compute_nullable_nonterminals()
#
# Creates a dictionary containing all of the non-terminals that might produce
# an empty production.
# -----------------------------------------------------------------------------
def compute_nullable_nonterminals():
nullable = {}
num_nullable = 0
while 1:
for p in Productions[1:]:
if p.len == 0:
nullable[p.name] = 1
continue
for t in p.prod:
if not nullable.has_key(t): break
else:
nullable[p.name] = 1
if len(nullable) == num_nullable: break
num_nullable = len(nullable)
return nullable
# -----------------------------------------------------------------------------
# find_nonterminal_trans(C)
#
# Given a set of LR(0) items, this functions finds all of the non-terminal
# transitions. These are transitions in which a dot appears immediately before
# a non-terminal. Returns a list of tuples of the form (state,N) where state
# is the state number and N is the nonterminal symbol.
#
# The input C is the set of LR(0) items.
# -----------------------------------------------------------------------------
def find_nonterminal_transitions(C):
trans = []
for state in range(len(C)):
for p in C[state]:
if p.lr_index < p.len - 1:
t = (state,p.prod[p.lr_index+1])
if Nonterminals.has_key(t[1]):
if t not in trans: trans.append(t)
state = state + 1
return trans
# -----------------------------------------------------------------------------
# dr_relation()
#
# Computes the DR(p,A) relationships for non-terminal transitions. The input
# is a tuple (state,N) where state is a number and N is a nonterminal symbol.
#
# Returns a list of terminals.
# -----------------------------------------------------------------------------
def dr_relation(C,trans,nullable):
dr_set = { }
state,N = trans
terms = []
g = lr0_goto(C[state],N)
for p in g:
if p.lr_index < p.len - 1:
a = p.prod[p.lr_index+1]
if Terminals.has_key(a):
if a not in terms: terms.append(a)
# This extra bit is to handle the start state
if state == 0 and N == Productions[0].prod[0]:
terms.append('$end')
return terms
# -----------------------------------------------------------------------------
# reads_relation()
#
# Computes the READS() relation (p,A) READS (t,C).
# -----------------------------------------------------------------------------
def reads_relation(C, trans, empty):
# Look for empty transitions
rel = []
state, N = trans
g = lr0_goto(C[state],N)
j = _lr0_cidhash.get(id(g),-1)
for p in g:
if p.lr_index < p.len - 1:
a = p.prod[p.lr_index + 1]
if empty.has_key(a):
rel.append((j,a))
return rel
# -----------------------------------------------------------------------------
# compute_lookback_includes()
#
# Determines the lookback and includes relations
#
# LOOKBACK:
#
# This relation is determined by running the LR(0) state machine forward.
# For example, starting with a production "N : . A B C", we run it forward
# to obtain "N : A B C ." We then build a relationship between this final
# state and the starting state. These relationships are stored in a dictionary
# lookdict.
#
# INCLUDES:
#
# Computes the INCLUDE() relation (p,A) INCLUDES (p',B).
#
# This relation is used to determine non-terminal transitions that occur
# inside of other non-terminal transition states. (p,A) INCLUDES (p', B)
# if the following holds:
#
# B -> LAT, where T -> epsilon and p' -L-> p
#
# L is essentially a prefix (which may be empty), T is a suffix that must be
# able to derive an empty string. State p' must lead to state p with the string L.
#
# -----------------------------------------------------------------------------
def compute_lookback_includes(C,trans,nullable):
lookdict = {} # Dictionary of lookback relations
includedict = {} # Dictionary of include relations
# Make a dictionary of non-terminal transitions
dtrans = {}
for t in trans:
dtrans[t] = 1
# Loop over all transitions and compute lookbacks and includes
for state,N in trans:
lookb = []
includes = []
for p in C[state]:
if p.name != N: continue
# Okay, we have a name match. We now follow the production all the way
# through the state machine until we get the . on the right hand side
lr_index = p.lr_index
j = state
while lr_index < p.len - 1:
lr_index = lr_index + 1
t = p.prod[lr_index]
# Check to see if this symbol and state are a non-terminal transition
if dtrans.has_key((j,t)):
# Yes. Okay, there is some chance that this is an includes relation
# the only way to know for certain is whether the rest of the
# production derives empty
li = lr_index + 1
while li < p.len:
if Terminals.has_key(p.prod[li]): break # No forget it
if not nullable.has_key(p.prod[li]): break
li = li + 1
else:
# Appears to be a relation between (j,t) and (state,N)
includes.append((j,t))
g = lr0_goto(C[j],t) # Go to next set
j = _lr0_cidhash.get(id(g),-1) # Go to next state
# When we get here, j is the final state, now we have to locate the production
for r in C[j]:
if r.name != p.name: continue
if r.len != p.len: continue
i = 0
# This look is comparing a production ". A B C" with "A B C ."
while i < r.lr_index:
if r.prod[i] != p.prod[i+1]: break
i = i + 1
else:
lookb.append((j,r))
for i in includes:
if not includedict.has_key(i): includedict[i] = []
includedict[i].append((state,N))
lookdict[(state,N)] = lookb
return lookdict,includedict
# -----------------------------------------------------------------------------
# digraph()
# traverse()
#
# The following two functions are used to compute set valued functions
# of the form:
#
# F(x) = F'(x) U U{F(y) | x R y}
#
# This is used to compute the values of Read() sets as well as FOLLOW sets
# in LALR(1) generation.
#
# Inputs: X - An input set
# R - A relation
# FP - Set-valued function
# ------------------------------------------------------------------------------
def digraph(X,R,FP):
N = { }
for x in X:
N[x] = 0
stack = []
F = { }
for x in X:
if N[x] == 0: traverse(x,N,stack,F,X,R,FP)
return F
def traverse(x,N,stack,F,X,R,FP):
stack.append(x)
d = len(stack)
N[x] = d
F[x] = FP(x) # F(X) <- F'(x)
rel = R(x) # Get y's related to x
for y in rel:
if N[y] == 0:
traverse(y,N,stack,F,X,R,FP)
N[x] = min(N[x],N[y])
for a in F.get(y,[]):
if a not in F[x]: F[x].append(a)
if N[x] == d:
N[stack[-1]] = sys.maxint
F[stack[-1]] = F[x]
element = stack.pop()
while element != x:
N[stack[-1]] = sys.maxint
F[stack[-1]] = F[x]
element = stack.pop()
# -----------------------------------------------------------------------------
# compute_read_sets()
#
# Given a set of LR(0) items, this function computes the read sets.
#
# Inputs: C = Set of LR(0) items
# ntrans = Set of nonterminal transitions
# nullable = Set of empty transitions
#
# Returns a set containing the read sets
# -----------------------------------------------------------------------------
def compute_read_sets(C, ntrans, nullable):
FP = lambda x: dr_relation(C,x,nullable)
R = lambda x: reads_relation(C,x,nullable)
F = digraph(ntrans,R,FP)
return F
# -----------------------------------------------------------------------------
# compute_follow_sets()
#
# Given a set of LR(0) items, a set of non-terminal transitions, a readset,
# and an include set, this function computes the follow sets
#
# Follow(p,A) = Read(p,A) U U {Follow(p',B) | (p,A) INCLUDES (p',B)}
#
# Inputs:
# ntrans = Set of nonterminal transitions
# readsets = Readset (previously computed)
# inclsets = Include sets (previously computed)
#
# Returns a set containing the follow sets
# -----------------------------------------------------------------------------
def compute_follow_sets(ntrans,readsets,inclsets):
FP = lambda x: readsets[x]
R = lambda x: inclsets.get(x,[])
F = digraph(ntrans,R,FP)
return F
# -----------------------------------------------------------------------------
# add_lookaheads()
#
# Attaches the lookahead symbols to grammar rules.
#
# Inputs: lookbacks - Set of lookback relations
# followset - Computed follow set
#
# This function directly attaches the lookaheads to productions contained
# in the lookbacks set
# -----------------------------------------------------------------------------
def add_lookaheads(lookbacks,followset):
for trans,lb in lookbacks.items():
# Loop over productions in lookback
for state,p in lb:
if not p.lookaheads.has_key(state):
p.lookaheads[state] = []
f = followset.get(trans,[])
for a in f:
if a not in p.lookaheads[state]: p.lookaheads[state].append(a)
# -----------------------------------------------------------------------------
# add_lalr_lookaheads()
#
# This function does all of the work of adding lookahead information for use
# with LALR parsing
# -----------------------------------------------------------------------------
def add_lalr_lookaheads(C):
# Determine all of the nullable nonterminals
nullable = compute_nullable_nonterminals()
# Find all non-terminal transitions
trans = find_nonterminal_transitions(C)
# Compute read sets
readsets = compute_read_sets(C,trans,nullable)
# Compute lookback/includes relations
lookd, included = compute_lookback_includes(C,trans,nullable)
# Compute LALR FOLLOW sets
followsets = compute_follow_sets(trans,readsets,included)
# Add all of the lookaheads
add_lookaheads(lookd,followsets)
# -----------------------------------------------------------------------------
# lr_parse_table()
#
# This function constructs the parse tables for SLR or LALR
# -----------------------------------------------------------------------------
def lr_parse_table(method):
global _lr_method
goto = _lr_goto # Goto array
action = _lr_action # Action array
actionp = { } # Action production array (temporary)
_lr_method = method
n_srconflict = 0
n_rrconflict = 0
if yaccdebug:
sys.stderr.write("yacc: Generating %s parsing table...\n" % method)
_vf.write("\n\nParsing method: %s\n\n" % method)
# Step 1: Construct C = { I0, I1, ... IN}, collection of LR(0) items
# This determines the number of states
C = lr0_items()
if method == 'LALR':
add_lalr_lookaheads(C)
# Build the parser table, state by state
st = 0
for I in C:
# Loop over each production in I
actlist = [ ] # List of actions
if yaccdebug:
_vf.write("\nstate %d\n\n" % st)
for p in I:
_vf.write(" (%d) %s\n" % (p.number, str(p)))
_vf.write("\n")
for p in I:
try:
if p.prod[-1] == ".":
if p.name == "S'":
# Start symbol. Accept!
action[st,"$end"] = 0
actionp[st,"$end"] = p
else:
# We are at the end of a production. Reduce!
if method == 'LALR':
laheads = p.lookaheads[st]
else:
laheads = Follow[p.name]
for a in laheads:
actlist.append((a,p,"reduce using rule %d (%s)" % (p.number,p)))
r = action.get((st,a),None)
if r is not None:
# Whoa. Have a shift/reduce or reduce/reduce conflict
if r > 0:
# Need to decide on shift or reduce here
# By default we favor shifting. Need to add
# some precedence rules here.
sprec,slevel = Productions[actionp[st,a].number].prec
rprec,rlevel = Precedence.get(a,('right',0))
if (slevel < rlevel) or ((slevel == rlevel) and (rprec == 'left')):
# We really need to reduce here.
action[st,a] = -p.number
actionp[st,a] = p
if not slevel and not rlevel:
_vfc.write("shift/reduce conflict in state %d resolved as reduce.\n" % st)
_vf.write(" ! shift/reduce conflict for %s resolved as reduce.\n" % a)
n_srconflict += 1
elif (slevel == rlevel) and (rprec == 'nonassoc'):
action[st,a] = None
else:
# Hmmm. Guess we'll keep the shift
if not rlevel:
_vfc.write("shift/reduce conflict in state %d resolved as shift.\n" % st)
_vf.write(" ! shift/reduce conflict for %s resolved as shift.\n" % a)
n_srconflict +=1
elif r < 0:
# Reduce/reduce conflict. In this case, we favor the rule
# that was defined first in the grammar file
oldp = Productions[-r]
pp = Productions[p.number]
if oldp.line > pp.line:
action[st,a] = -p.number
actionp[st,a] = p
# sys.stderr.write("Reduce/reduce conflict in state %d\n" % st)
n_rrconflict += 1
_vfc.write("reduce/reduce conflict in state %d resolved using rule %d (%s).\n" % (st, actionp[st,a].number, actionp[st,a]))
_vf.write(" ! reduce/reduce conflict for %s resolved using rule %d (%s).\n" % (a,actionp[st,a].number, actionp[st,a]))
else:
sys.stderr.write("Unknown conflict in state %d\n" % st)
else:
action[st,a] = -p.number
actionp[st,a] = p
else:
i = p.lr_index
a = p.prod[i+1] # Get symbol right after the "."
if Terminals.has_key(a):
g = lr0_goto(I,a)
j = _lr0_cidhash.get(id(g),-1)
if j >= 0:
# We are in a shift state
actlist.append((a,p,"shift and go to state %d" % j))
r = action.get((st,a),None)
if r is not None:
# Whoa have a shift/reduce or shift/shift conflict
if r > 0:
if r != j:
sys.stderr.write("Shift/shift conflict in state %d\n" % st)
elif r < 0:
# Do a precedence check.
# - if precedence of reduce rule is higher, we reduce.
# - if precedence of reduce is same and left assoc, we reduce.
# - otherwise we shift
rprec,rlevel = Productions[actionp[st,a].number].prec
sprec,slevel = Precedence.get(a,('right',0))
if (slevel > rlevel) or ((slevel == rlevel) and (rprec != 'left')):
# We decide to shift here... highest precedence to shift
action[st,a] = j
actionp[st,a] = p
if not rlevel:
n_srconflict += 1
_vfc.write("shift/reduce conflict in state %d resolved as shift.\n" % st)
_vf.write(" ! shift/reduce conflict for %s resolved as shift.\n" % a)
elif (slevel == rlevel) and (rprec == 'nonassoc'):
action[st,a] = None
else:
# Hmmm. Guess we'll keep the reduce
if not slevel and not rlevel:
n_srconflict +=1
_vfc.write("shift/reduce conflict in state %d resolved as reduce.\n" % st)
_vf.write(" ! shift/reduce conflict for %s resolved as reduce.\n" % a)
else:
sys.stderr.write("Unknown conflict in state %d\n" % st)
else:
action[st,a] = j
actionp[st,a] = p
except StandardError,e:
raise YaccError, "Hosed in lr_parse_table", e
# Print the actions associated with each terminal
if yaccdebug:
_actprint = { }
for a,p,m in actlist:
if action.has_key((st,a)):
if p is actionp[st,a]:
_vf.write(" %-15s %s\n" % (a,m))
_actprint[(a,m)] = 1
_vf.write("\n")
for a,p,m in actlist:
if action.has_key((st,a)):
if p is not actionp[st,a]:
if not _actprint.has_key((a,m)):
_vf.write(" ! %-15s [ %s ]\n" % (a,m))
_actprint[(a,m)] = 1
# Construct the goto table for this state
if yaccdebug:
_vf.write("\n")
nkeys = { }
for ii in I:
for s in ii.usyms:
if Nonterminals.has_key(s):
nkeys[s] = None
for n in nkeys.keys():
g = lr0_goto(I,n)
j = _lr0_cidhash.get(id(g),-1)
if j >= 0:
goto[st,n] = j
if yaccdebug:
_vf.write(" %-30s shift and go to state %d\n" % (n,j))
st += 1
if yaccdebug:
if n_srconflict == 1:
sys.stderr.write("yacc: %d shift/reduce conflict\n" % n_srconflict)
if n_srconflict > 1:
sys.stderr.write("yacc: %d shift/reduce conflicts\n" % n_srconflict)
if n_rrconflict == 1:
sys.stderr.write("yacc: %d reduce/reduce conflict\n" % n_rrconflict)
if n_rrconflict > 1:
sys.stderr.write("yacc: %d reduce/reduce conflicts\n" % n_rrconflict)
# -----------------------------------------------------------------------------
# ==== LR Utility functions ====
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# _lr_write_tables()
#
# This function writes the LR parsing tables to a file
# -----------------------------------------------------------------------------
def lr_write_tables(modulename=tab_module,outputdir=''):
filename = os.path.join(outputdir,modulename) + ".py"
try:
f = open(filename,"w")
f.write("""
# %s
# This file is automatically generated. Do not edit.
_lr_method = %s
_lr_signature = %s
""" % (filename, repr(_lr_method), repr(Signature.digest())))
# Change smaller to 0 to go back to original tables
smaller = 1
# Factor out names to try and make smaller
if smaller:
items = { }
for k,v in _lr_action.items():
i = items.get(k[1])
if not i:
i = ([],[])
items[k[1]] = i
i[0].append(k[0])
i[1].append(v)
f.write("\n_lr_action_items = {")
for k,v in items.items():
f.write("%r:([" % k)
for i in v[0]:
f.write("%r," % i)
f.write("],[")
for i in v[1]:
f.write("%r," % i)
f.write("]),")
f.write("}\n")
f.write("""
_lr_action = { }
for _k, _v in _lr_action_items.items():
for _x,_y in zip(_v[0],_v[1]):
_lr_action[(_x,_k)] = _y
del _lr_action_items
""")
else:
f.write("\n_lr_action = { ");
for k,v in _lr_action.items():
f.write("(%r,%r):%r," % (k[0],k[1],v))
f.write("}\n");
if smaller:
# Factor out names to try and make smaller
items = { }
for k,v in _lr_goto.items():
i = items.get(k[1])
if not i:
i = ([],[])
items[k[1]] = i
i[0].append(k[0])
i[1].append(v)
f.write("\n_lr_goto_items = {")
for k,v in items.items():
f.write("%r:([" % k)
for i in v[0]:
f.write("%r," % i)
f.write("],[")
for i in v[1]:
f.write("%r," % i)
f.write("]),")
f.write("}\n")
f.write("""
_lr_goto = { }
for _k, _v in _lr_goto_items.items():
for _x,_y in zip(_v[0],_v[1]):
_lr_goto[(_x,_k)] = _y
del _lr_goto_items
""")
else:
f.write("\n_lr_goto = { ");
for k,v in _lr_goto.items():
f.write("(%r,%r):%r," % (k[0],k[1],v))
f.write("}\n");
# Write production table
f.write("_lr_productions = [\n")
for p in Productions:
if p:
if (p.func):
f.write(" (%r,%d,%r,%r,%d),\n" % (p.name, p.len, p.func.__name__,p.file,p.line))
else:
f.write(" (%r,%d,None,None,None),\n" % (p.name, p.len))
else:
f.write(" None,\n")
f.write("]\n")
f.close()
except IOError,e:
print "Unable to create '%s'" % filename
print e
return
def lr_read_tables(module=tab_module,optimize=0):
global _lr_action, _lr_goto, _lr_productions, _lr_method
try:
exec "import %s as parsetab" % module
if (optimize) or (Signature.digest() == parsetab._lr_signature):
_lr_action = parsetab._lr_action
_lr_goto = parsetab._lr_goto
_lr_productions = parsetab._lr_productions
_lr_method = parsetab._lr_method
return 1
else:
return 0
except (ImportError,AttributeError):
return 0
# Available instance types. This is used when parsers are defined by a class.
# it's a little funky because I want to preserve backwards compatibility
# with Python 2.0 where types.ObjectType is undefined.
try:
_INSTANCETYPE = (types.InstanceType, types.ObjectType)
except AttributeError:
_INSTANCETYPE = types.InstanceType
# -----------------------------------------------------------------------------
# yacc(module)
#
# Build the parser module
# -----------------------------------------------------------------------------
# <ah> Add parserclass parameter.
def yacc(method=default_lr, debug=yaccdebug, module=None, tabmodule=tab_module, start=None, check_recursion=1, optimize=0,write_tables=1,debugfile=debug_file,outputdir='', parserclass=Parser):
global yaccdebug
yaccdebug = debug
initialize_vars()
files = { }
error = 0
# Add parsing method to signature
Signature.update(method)
# If a "module" parameter was supplied, extract its dictionary.
# Note: a module may in fact be an instance as well.
if module:
# User supplied a module object.
if isinstance(module, types.ModuleType):
ldict = module.__dict__
elif isinstance(module, _INSTANCETYPE):
_items = [(k,getattr(module,k)) for k in dir(module)]
ldict = { }
for i in _items:
ldict[i[0]] = i[1]
else:
raise ValueError,"Expected a module"
else:
# No module given. We might be able to get information from the caller.
# Throw an exception and unwind the traceback to get the globals
try:
raise RuntimeError
except RuntimeError:
e,b,t = sys.exc_info()
f = t.tb_frame
f = f.f_back # Walk out to our calling function
ldict = f.f_globals # Grab its globals dictionary
# Add starting symbol to signature
if not start:
start = ldict.get("start",None)
if start:
Signature.update(start)
# If running in optimized mode. We're going to
if (optimize and lr_read_tables(tabmodule,1)):
# Read parse table
del Productions[:]
for p in _lr_productions:
if not p:
Productions.append(None)
else:
m = MiniProduction()
m.name = p[0]
m.len = p[1]
m.file = p[3]
m.line = p[4]
if p[2]:
m.func = ldict[p[2]]
Productions.append(m)
else:
# Get the tokens map
if (module and isinstance(module,_INSTANCETYPE)):
tokens = getattr(module,"tokens",None)
else:
tokens = ldict.get("tokens",None)
if not tokens:
raise YaccError,"module does not define a list 'tokens'"
if not (isinstance(tokens,types.ListType) or isinstance(tokens,types.TupleType)):
raise YaccError,"tokens must be a list or tuple."
# Check to see if a requires dictionary is defined.
requires = ldict.get("require",None)
if requires:
if not (isinstance(requires,types.DictType)):
raise YaccError,"require must be a dictionary."
for r,v in requires.items():
try:
if not (isinstance(v,types.ListType)):
raise TypeError
v1 = [x.split(".") for x in v]
Requires[r] = v1
except StandardError:
print "Invalid specification for rule '%s' in require. Expected a list of strings" % r
# Build the dictionary of terminals. We a record a 0 in the
# dictionary to track whether or not a terminal is actually
# used in the grammar
if 'error' in tokens:
print "yacc: Illegal token 'error'. Is a reserved word."
raise YaccError,"Illegal token name"
for n in tokens:
if Terminals.has_key(n):
print "yacc: Warning. Token '%s' multiply defined." % n
Terminals[n] = [ ]
Terminals['error'] = [ ]
# Get the precedence map (if any)
prec = ldict.get("precedence",None)
if prec:
if not (isinstance(prec,types.ListType) or isinstance(prec,types.TupleType)):
raise YaccError,"precedence must be a list or tuple."
add_precedence(prec)
Signature.update(repr(prec))
for n in tokens:
if not Precedence.has_key(n):
Precedence[n] = ('right',0) # Default, right associative, 0 precedence
# Look for error handler
ef = ldict.get('p_error',None)
if ef:
if isinstance(ef,types.FunctionType):
ismethod = 0
elif isinstance(ef, types.MethodType):
ismethod = 1
else:
raise YaccError,"'p_error' defined, but is not a function or method."
eline = ef.func_code.co_firstlineno
efile = ef.func_code.co_filename
files[efile] = None
if (ef.func_code.co_argcount != 1+ismethod):
raise YaccError,"%s:%d: p_error() requires 1 argument." % (efile,eline)
global Errorfunc
Errorfunc = ef
else:
print "yacc: Warning. no p_error() function is defined."
# Get the list of built-in functions with p_ prefix
symbols = [ldict[f] for f in ldict.keys()
if (type(ldict[f]) in (types.FunctionType, types.MethodType) and ldict[f].__name__[:2] == 'p_'
and ldict[f].__name__ != 'p_error')]
# Check for non-empty symbols
if len(symbols) == 0:
raise YaccError,"no rules of the form p_rulename are defined."
# Sort the symbols by line number
symbols.sort(lambda x,y: cmp(x.func_code.co_firstlineno,y.func_code.co_firstlineno))
# Add all of the symbols to the grammar
for f in symbols:
if (add_function(f)) < 0:
error += 1
else:
files[f.func_code.co_filename] = None
# Make a signature of the docstrings
for f in symbols:
if f.__doc__:
Signature.update(f.__doc__)
lr_init_vars()
if error:
raise YaccError,"Unable to construct parser."
if not lr_read_tables(tabmodule):
# Validate files
for filename in files.keys():
if not validate_file(filename):
error = 1
# Validate dictionary
validate_dict(ldict)
if start and not Prodnames.has_key(start):
raise YaccError,"Bad starting symbol '%s'" % start
augment_grammar(start)
error = verify_productions(cycle_check=check_recursion)
otherfunc = [ldict[f] for f in ldict.keys()
if (type(f) in (types.FunctionType,types.MethodType) and ldict[f].__name__[:2] != 'p_')]
if error:
raise YaccError,"Unable to construct parser."
build_lritems()
compute_first1()
compute_follow(start)
if method in ['SLR','LALR']:
lr_parse_table(method)
else:
raise YaccError, "Unknown parsing method '%s'" % method
if write_tables:
lr_write_tables(tabmodule,outputdir)
if yaccdebug:
try:
f = open(os.path.join(outputdir,debugfile),"w")
f.write(_vfc.getvalue())
f.write("\n\n")
f.write(_vf.getvalue())
f.close()
except IOError,e:
print "yacc: can't create '%s'" % debugfile,e
# Made it here. Create a parser object and set up its internal state.
# Set global parse() method to bound method of parser object.
g = ParserPrototype("xyzzy")
g.productions = Productions
g.errorfunc = Errorfunc
g.action = _lr_action
g.goto = _lr_goto
g.method = _lr_method
g.require = Requires
global parser
parser = g.init_parser()
global parse
parse = parser.parse
# Clean up all of the globals we created
if (not optimize):
yacc_cleanup()
return g
# <ah> Allow multiple instances of parser
class ParserPrototype(object):
def __init__(self, magic=None):
if magic != "xyzzy":
raise YaccError, 'Use yacc()'
def init_parser(self, parser=None):
if not parser:
parser = Parser()
parser.productions = self.productions
parser.errorfunc = self.errorfunc
parser.action = self.action
parser.goto = self.goto
parser.method = self.method
parser.require = self.require
return parser
# yacc_cleanup function. Delete all of the global variables
# used during table construction
def yacc_cleanup():
global _lr_action, _lr_goto, _lr_method, _lr_goto_cache
del _lr_action, _lr_goto, _lr_method, _lr_goto_cache
global Productions, Prodnames, Prodmap, Terminals
global Nonterminals, First, Follow, Precedence, LRitems
global Errorfunc, Signature, Requires
del Productions, Prodnames, Prodmap, Terminals
del Nonterminals, First, Follow, Precedence, LRitems
del Errorfunc, Signature, Requires
global _vf, _vfc
del _vf, _vfc
# Stub that raises an error if parsing is attempted without first calling yacc()
def parse(*args,**kwargs):
raise YaccError, "yacc: No parser built with yacc()"
| Python |
#!/usr/bin/env python
'''A package for generating ctypes wrappers from a C header file. See the
docstring for wrap.py for usage.
The files 'lex.py' and 'yacc.py' are from PLY (http://www.dabeaz.com/ply),
which was written by David M. Beazley but have been modified slightly
for this tool.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from cparser import *
ctypes_type_map = {
# typename signed longs
('void', True, 0): 'None',
('int', True, 0): 'c_int',
('int', False, 0): 'c_uint',
('int', True, 1): 'c_long',
('int', False, 1): 'c_ulong',
('int', True, 2): 'c_longlong',
('int', False, 2): 'c_ulonglong',
('char', True, 0): 'c_char',
('char', False, 0): 'c_ubyte',
('short', True, 0): 'c_short',
('short', False, 0): 'c_ushort',
('float', True, 0): 'c_float',
('double', True, 0): 'c_double',
('size_t', True, 0): 'c_size_t',
('int8_t', True, 0): 'c_int8',
('int16_t', True, 0): 'c_int16',
('int32_t', True, 0): 'c_int32',
('int64_t', True, 0): 'c_int64',
('uint8_t', True, 0): 'c_uint8',
('uint16_t',True, 0): 'c_uint16',
('uint32_t',True, 0): 'c_uint32',
('uint64_t',True, 0): 'c_uint64',
('wchar_t', True, 0): 'c_wchar',
('ptrdiff_t',True, 0): 'c_ptrdiff_t', # Requires definition in preamble
}
reserved_names = ['None', 'True', 'False']
def get_ctypes_type(typ, declarator):
signed = True
typename = 'int'
longs = 0
t = None
for specifier in typ.specifiers:
if isinstance(specifier, StructTypeSpecifier):
t = CtypesStruct(specifier)
elif isinstance(specifier, EnumSpecifier):
t = CtypesEnum(specifier)
elif specifier == 'signed':
signed = True
elif specifier == 'unsigned':
signed = False
elif specifier == 'long':
longs += 1
else:
typename = str(specifier)
if not t:
ctypes_name = ctypes_type_map.get((typename, signed, longs), typename)
t = CtypesType(ctypes_name)
while declarator and declarator.pointer:
if declarator.parameters is not None:
t = CtypesFunction(t, declarator.parameters)
a = declarator.array
while a:
t = CtypesArray(t, a.size)
a = a.array
if type(t) == CtypesType and t.name == 'c_char':
t = CtypesType('c_char_p')
elif type(t) == CtypesType and t.name == 'c_wchar':
t = CtypesType('c_wchar_p')
else:
t = CtypesPointer(t, declarator.qualifiers)
declarator = declarator.pointer
if declarator and declarator.parameters is not None:
t = CtypesFunction(t, declarator.parameters)
if declarator:
a = declarator.array
while a:
t = CtypesArray(t, a.size)
a = a.array
return t
# Remove one level of indirection from funtion pointer; needed for typedefs
# and function parameters.
def remove_function_pointer(t):
if type(t) == CtypesPointer and type(t.destination) == CtypesFunction:
return t.destination
elif type(t) == CtypesPointer:
t.destination = remove_function_pointer(t.destination)
return t
else:
return t
class CtypesTypeVisitor(object):
def visit_struct(self, struct):
pass
def visit_enum(self, enum):
pass
class CtypesType(object):
def __init__(self, name):
self.name = name
def get_required_type_names(self):
'''Return all type names defined or needed by this type'''
return (self.name,)
def visit(self, visitor):
pass
def __str__(self):
return self.name
class CtypesPointer(CtypesType):
def __init__(self, destination, qualifiers):
self.destination = destination
# ignore qualifiers, ctypes can't use them
def get_required_type_names(self):
if self.destination:
return self.destination.get_required_type_names()
else:
return ()
def visit(self, visitor):
if self.destination:
self.destination.visit(visitor)
def __str__(self):
return 'POINTER(%s)' % str(self.destination)
class CtypesArray(CtypesType):
def __init__(self, base, count):
self.base = base
self.count = count
def get_required_type_names(self):
# XXX Could be sizeofs within count expression
return self.base.get_required_type_names()
def visit(self, visitor):
# XXX Could be sizeofs within count expression
self.base.visit(visitor)
def __str__(self):
if self.count is None:
return 'POINTER(%s)' % str(self.base)
if type(self.base) == CtypesArray:
return '(%s) * %s' % (str(self.base), str(self.count))
else:
return '%s * %s' % (str(self.base), str(self.count))
class CtypesFunction(CtypesType):
def __init__(self, restype, parameters):
if parameters and parameters[-1] == '...':
# XXX Hmm, how to handle VARARGS with ctypes? For now,
# drop it off (will cause errors).
parameters = parameters[:-1]
self.restype = restype
# Don't allow POINTER(None) (c_void_p) as a restype... causes errors
# when ctypes automagically returns it as an int.
# Instead, convert to POINTER(c_void). c_void is not a ctypes type,
# you can make it any arbitrary type.
if type(self.restype) == CtypesPointer and \
type(self.restype.destination) == CtypesType and \
self.restype.destination.name == 'None':
self.restype = CtypesPointer(CtypesType('c_void'), ())
self.argtypes = [remove_function_pointer(
get_ctypes_type(p.type, p.declarator)) \
for p in parameters]
def get_required_type_names(self):
lst = list(self.restype.get_required_type_names())
for a in self.argtypes:
lst += list(a.get_required_type_names())
return lst
def visit(self, visitor):
self.restype.visit(visitor)
for a in self.argtypes:
a.visit(visitor)
def __str__(self):
return 'CFUNCTYPE(%s)' % ', '.join([str(self.restype)] + \
[str(a) for a in self.argtypes])
last_tagnum = 0
def anonymous_struct_tag():
global last_tagnum
last_tagnum += 1
return 'anon_%d' % last_tagnum
class CtypesStruct(CtypesType):
def __init__(self, specifier):
self.is_union = specifier.is_union
self.tag = specifier.tag
if not self.tag:
self.tag = anonymous_struct_tag()
if specifier.declarations:
self.opaque = False
self.members = []
for declaration in specifier.declarations:
t = get_ctypes_type(declaration.type, declaration.declarator)
declarator = declaration.declarator
if declarator is None:
# XXX TEMPORARY while struct with no typedef not filled in
return
while declarator.pointer:
declarator = declarator.pointer
name = declarator.identifier
self.members.append((name, t))
else:
self.opaque = True
self.members = []
def get_required_type_names(self):
lst = ['struct_%s' % self.tag]
for m in self.members:
lst += m[1].get_required_type_names()
return lst
def visit(self, visitor):
visitor.visit_struct(self)
def __str__(self):
return 'struct_%s' % self.tag
last_tagnum = 0
def anonymous_enum_tag():
global last_tagnum
last_tagnum += 1
return 'anon_%d' % last_tagnum
class CtypesEnum(CtypesType):
def __init__(self, specifier):
self.tag = specifier.tag
if not self.tag:
self.tag = anonymous_enum_tag()
value = 0
context = EvaluationContext()
self.enumerators = []
for e in specifier.enumerators:
if e.expression:
try:
value = int(e.expression.evaluate(context))
except:
pass
self.enumerators.append((e.name, value))
value += 1
def get_required_type_names(self):
return []
def visit(self, visitor):
visitor.visit_enum(self)
def __str__(self):
return 'enum_%s' % self.tag
class CtypesParser(CParser):
'''Parse a C file for declarations that can be used by ctypes.
Subclass and override the handle_ctypes_* methods.
'''
def handle_define(self, name, value, filename, lineno):
# Handle #define style of typedeffing.
# XXX At the moment, just a hack for `int`, which is used by
# Status and Bool in Xlib.h. More complete functionality would
# parse value as a type (back into cparser).
if value == 'int':
t = CtypesType('c_int')
self.handle_ctypes_type_definition(
name, t, filename, lineno)
def handle_define_constant(self, name, value, filename, lineno):
if name in reserved_names:
name += '_'
self.handle_ctypes_constant(name, value, filename, lineno)
def handle_declaration(self, declaration, filename, lineno):
t = get_ctypes_type(declaration.type, declaration.declarator)
declarator = declaration.declarator
if declarator is None:
# XXX TEMPORARY while struct with no typedef not filled in
return
while declarator.pointer:
declarator = declarator.pointer
name = declarator.identifier
if declaration.storage == 'typedef':
self.handle_ctypes_type_definition(
name, remove_function_pointer(t), filename, lineno)
elif type(t) == CtypesFunction:
self.handle_ctypes_function(
name, t.restype, t.argtypes, filename, lineno)
elif declaration.storage != 'static':
self.handle_ctypes_variable(name, t, filename, lineno)
# ctypes parser interface. Override these methods in your subclass.
def handle_ctypes_constant(self, name, value, filename, lineno):
pass
def handle_ctypes_type_definition(self, name, ctype, filename, lineno):
pass
def handle_ctypes_function(self, name, restype, argtypes, filename, lineno):
pass
def handle_ctypes_variable(self, name, ctype, filename, lineno):
pass
| Python |
#!/usr/bin/env python
'''Preprocess a C source file.
Limitations:
* Whitespace is not preserved.
* # and ## operators not handled.
Reference is C99:
* http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf
* Also understands Objective-C #import directive
* Also understands GNU #include_next
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import operator
import os.path
import cPickle
import re
import sys
import lex
from lex import TOKEN
import yacc
tokens = (
'HEADER_NAME', 'IDENTIFIER', 'PP_NUMBER', 'CHARACTER_CONSTANT',
'STRING_LITERAL', 'OTHER',
'PTR_OP', 'INC_OP', 'DEC_OP', 'LEFT_OP', 'RIGHT_OP', 'LE_OP', 'GE_OP',
'EQ_OP', 'NE_OP', 'AND_OP', 'OR_OP', 'MUL_ASSIGN', 'DIV_ASSIGN',
'MOD_ASSIGN', 'ADD_ASSIGN', 'SUB_ASSIGN', 'LEFT_ASSIGN', 'RIGHT_ASSIGN',
'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN', 'HASH_HASH', 'PERIOD',
'ELLIPSIS',
'IF', 'IFDEF', 'IFNDEF', 'ELIF', 'ELSE', 'ENDIF', 'INCLUDE',
'INCLUDE_NEXT', 'DEFINE', 'UNDEF', 'LINE', 'ERROR', 'PRAGMA', 'DEFINED',
'IMPORT',
'NEWLINE', 'LPAREN'
)
subs = {
'D': '[0-9]',
'L': '[a-zA-Z_]',
'H': '[a-fA-F0-9]',
'E': '[Ee][+-]?{D}+',
'FS': '[FflL]',
'IS': '[uUlL]*',
}
# Helper: substitute {foo} with subs[foo] in string (makes regexes more lexy)
sub_pattern = re.compile('{([^}]*)}')
def sub_repl_match(m):
return subs[m.groups()[0]]
def sub(s):
return sub_pattern.sub(sub_repl_match, s)
CHARACTER_CONSTANT = sub(r"L?'(\\.|[^\\'])+'")
STRING_LITERAL = sub(r'L?"(\\.|[^\\"])*"')
IDENTIFIER = sub('{L}({L}|{D})*')
# --------------------------------------------------------------------------
# Token value types
# --------------------------------------------------------------------------
# Numbers represented as int and float types.
# For all other tokens, type is just str representation.
class StringLiteral(str):
def __new__(cls, value):
assert value[0] == '"' and value[-1] == '"'
# Unescaping probably not perfect but close enough.
value = value[1:-1].decode('string_escape')
return str.__new__(cls, value)
class SystemHeaderName(str):
def __new__(cls, value):
assert value[0] == '<' and value[-1] == '>'
return str.__new__(cls, value[1:-1])
def __repr__(self):
return '<%s>' % (str(self))
# --------------------------------------------------------------------------
# Token declarations
# --------------------------------------------------------------------------
punctuators = {
# value: (regex, type)
r'...': (r'\.\.\.', 'ELLIPSIS'),
r'>>=': (r'>>=', 'RIGHT_ASSIGN'),
r'<<=': (r'<<=', 'LEFT_ASSIGN'),
r'+=': (r'\+=', 'ADD_ASSIGN'),
r'-=': (r'-=', 'SUB_ASSIGN'),
r'*=': (r'\*=', 'MUL_ASSIGN'),
r'/=': (r'/=', 'DIV_ASSIGN'),
r'%=': (r'%=', 'MOD_ASSIGN'),
r'&=': (r'&=', 'AND_ASSIGN'),
r'^=': (r'\^=', 'XOR_ASSIGN'),
r'|=': (r'\|=', 'OR_ASSIGN'),
r'>>': (r'>>', 'RIGHT_OP'),
r'<<': (r'<<', 'LEFT_OP'),
r'++': (r'\+\+', 'INC_OP'),
r'--': (r'--', 'DEC_OP'),
r'->': (r'->', 'PTR_OP'),
r'&&': (r'&&', 'AND_OP'),
r'||': (r'\|\|', 'OR_OP'),
r'<=': (r'<=', 'LE_OP'),
r'>=': (r'>=', 'GE_OP'),
r'==': (r'==', 'EQ_OP'),
r'!=': (r'!=', 'NE_OP'),
r'<:': (r'<:', '['),
r':>': (r':>', ']'),
r'<%': (r'<%', '{'),
r'%>': (r'%>', '}'),
r'%:%:': (r'%:%:', 'HASH_HASH'),
r';': (r';', ';'),
r'{': (r'{', '{'),
r'}': (r'}', '}'),
r',': (r',', ','),
r':': (r':', ':'),
r'=': (r'=', '='),
r')': (r'\)', ')'),
r'[': (r'\[', '['),
r']': (r']', ']'),
r'.': (r'\.', 'PERIOD'),
r'&': (r'&', '&'),
r'!': (r'!', '!'),
r'~': (r'~', '~'),
r'-': (r'-', '-'),
r'+': (r'\+', '+'),
r'*': (r'\*', '*'),
r'/': (r'/', '/'),
r'%': (r'%', '%'),
r'<': (r'<', '<'),
r'>': (r'>', '>'),
r'^': (r'\^', '^'),
r'|': (r'\|', '|'),
r'?': (r'\?', '?'),
r'#': (r'\#', '#'),
}
def punctuator_regex(punctuators):
punctuator_regexes = [v[0] for v in punctuators.values()]
punctuator_regexes.sort(lambda a, b: -cmp(len(a), len(b)))
return '(%s)' % '|'.join(punctuator_regexes)
def t_clinecomment(t):
r'//[^\n]*'
t.lexer.lineno += 1
def t_cr(t):
r'\r'
# Skip over CR characters. Only necessary on urlopen'd files.
# C /* comments */. Copied from the ylex.py example in PLY: it's not 100%
# correct for ANSI C, but close enough for anything that's not crazy.
def t_ccomment(t):
r'/\*(.|\n)*?\*/'
t.lexer.lineno += t.value.count('\n')
def t_header_name(t):
r'<([\/]?[^\/\*\n>])*[\/]?>(?=[ \t\f\v\r\n])'
# Should allow any character from charset, but that wreaks havok (skips
# comment delimiter, for instance), so also don't permit '*' or '//'
# The non-matching group at the end prevents false-positives with
# operators like '>='.
# In the event of a false positive (e.g. "if (a < b || c > d)"), the
# token will be split and rescanned if it appears in a text production;
# see PreprocessorParser.write.
# Is also r'"[^\n"]"', but handled in STRING_LITERAL instead.
t.type = 'HEADER_NAME'
t.value = SystemHeaderName(t.value)
return t
def t_directive(t):
r'\#[ \t]*(ifdef|ifndef|if|elif|else|endif|define|undef|include_next|include|import|line|error|pragma)'
if t.lexer.lasttoken in ('NEWLINE', None):
t.type = t.value[1:].lstrip().upper()
else:
# TODO
t.type = '#'
t.lexer.nexttoken = ('IDENTIFIER', t.value[1:].lstrip())
return t
@TOKEN(punctuator_regex(punctuators))
def t_punctuator(t):
t.type = punctuators[t.value][1]
return t
@TOKEN(CHARACTER_CONSTANT)
def t_character_constant(t):
t.type = 'CHARACTER_CONSTANT'
return t
@TOKEN(IDENTIFIER)
def t_identifier(t):
if t.value == 'defined':
t.type = 'DEFINED'
else:
t.type = 'IDENTIFIER'
return t
# missing: universal-character-constant
@TOKEN(sub(r'({D}|\.{D})({D}|{L}|e[+-]|E[+-]|p[+-]|P[+-]|\.)*'))
def t_pp_number(t):
t.type = 'PP_NUMBER'
return t
@TOKEN(STRING_LITERAL)
def t_string_literal(t):
t.type = 'STRING_LITERAL'
t.value = StringLiteral(t.value)
return t
def t_lparen(t):
r'\('
if t.lexpos == 0 or t.lexer.lexdata[t.lexpos-1] not in (' \t\f\v\n'):
t.type = 'LPAREN'
else:
t.type = '('
return t
def t_continuation(t):
r'\\\n'
t.lexer.lineno += 1
return None
def t_newline(t):
r'\n'
t.lexer.lineno += 1
t.type = 'NEWLINE'
return t
def t_error(t):
t.type = 'OTHER'
return t
t_ignore = ' \t\v\f'
# --------------------------------------------------------------------------
# Expression Object Model
# --------------------------------------------------------------------------
class EvaluationContext(object):
'''Interface for evaluating expression nodes.
'''
def is_defined(self, identifier):
return False
class ExpressionNode(object):
def evaluate(self, context):
return 0
def __str__(self):
return ''
class ConstantExpressionNode(ExpressionNode):
def __init__(self, value):
self.value = value
def evaluate(self, context):
return self.value
def __str__(self):
return str(self.value)
class UnaryExpressionNode(ExpressionNode):
def __init__(self, op, op_str, child):
self.op = op
self.op_str = op_str
self.child = child
def evaluate(self, context):
return self.op(self.child.evaluate(context))
def __str__(self):
return '(%s %s)' % (self.op_str, self.child)
class BinaryExpressionNode(ExpressionNode):
def __init__(self, op, op_str, left, right):
self.op = op
self.op_str = op_str
self.left = left
self.right = right
def evaluate(self, context):
return self.op(self.left.evaluate(context),
self.right.evaluate(context))
def __str__(self):
return '(%s %s %s)' % (self.left, self.op_str, self.right)
class LogicalAndExpressionNode(ExpressionNode):
def __init__(self, left, right):
self.left = left
self.right = right
def evaluate(self, context):
return self.left.evaluate(context) and self.right.evaluate(context)
def __str__(self):
return '(%s && %s)' % (self.left, self.right)
class LogicalOrExpressionNode(ExpressionNode):
def __init__(self, left, right):
self.left = left
self.right = right
def evaluate(self, context):
return self.left.evaluate(context) or self.right.evaluate(context)
def __str__(self):
return '(%s || %s)' % (self.left, self.right)
class ConditionalExpressionNode(ExpressionNode):
def __init__(self, condition, left, right):
self.condition = condition
self.left = left
self.right = right
def evaluate(self, context):
if self.condition.evaluate(context):
return self.left.evaluate(context)
else:
return self.right.evaluate(context)
def __str__(self):
return '(%s ? %s : %s)' % (self.condition, self.left, self.right)
# --------------------------------------------------------------------------
# Lexers
# --------------------------------------------------------------------------
class PreprocessorLexer(lex.Lexer):
def __init__(self):
lex.Lexer.__init__(self)
self.filename = '<input>'
def input(self, data, filename=None):
if filename:
self.filename = filename
self.lasttoken = None
self.input_stack = []
lex.Lexer.input(self, data)
def push_input(self, data, filename):
self.input_stack.append(
(self.lexdata, self.lexpos, self.filename, self.lineno))
self.lexdata = data
self.lexpos = 0
self.lineno = 1
self.filename = filename
self.lexlen = len(self.lexdata)
def pop_input(self):
self.lexdata, self.lexpos, self.filename, self.lineno = \
self.input_stack.pop()
self.lexlen = len(self.lexdata)
def token(self):
result = lex.Lexer.token(self)
while result is None and self.input_stack:
self.pop_input()
result = lex.Lexer.token(self)
if result:
self.lasttoken = result.type
result.filename = self.filename
else:
self.lasttoken = None
return result
class TokenListLexer(object):
def __init__(self, tokens):
self.tokens = tokens
self.pos = 0
def token(self):
if self.pos < len(self.tokens):
t = self.tokens[self.pos]
self.pos += 1
return t
else:
return None
def symbol_to_token(sym):
if isinstance(sym, yacc.YaccSymbol):
return sym.value
elif isinstance(sym, lex.LexToken):
return sym
else:
assert False, 'Not a symbol: %r' % sym
def create_token(type, value, production=None):
'''Create a token of type and value, at the position where 'production'
was reduced. Don't specify production if the token is built-in'''
t = lex.LexToken()
t.type = type
t.value = value
t.lexpos = -1
if production:
t.lineno = production.slice[1].lineno
t.filename = production.slice[1].filename
else:
t.lineno = -1
t.filename = '<builtin>'
return t
# --------------------------------------------------------------------------
# Grammars
# --------------------------------------------------------------------------
class Grammar(object):
prototype = None
name = 'grammar'
@classmethod
def get_prototype(cls):
if not cls.prototype:
instance = cls()
tabmodule = '%stab' % cls.name
cls.prototype = yacc.yacc(module=instance, tabmodule=tabmodule)
return cls.prototype
class PreprocessorGrammar(Grammar):
tokens = tokens
name = 'pp'
def p_preprocessing_file(self, p):
'''preprocessing_file : group_opt
'''
def p_group_opt(self, p):
'''group_opt : group
|
'''
def p_group(self, p):
'''group : group_part
| group group_part
'''
def p_group_part(self, p):
'''group_part : if_section
| control_line
| text_line
'''
def p_if_section(self, p):
'''if_section : if_group elif_groups_opt else_group_opt endif_line
'''
def p_if_group(self, p):
'''if_group : if_line group_opt
'''
def p_if_line(self, p):
'''if_line : IF replaced_constant_expression NEWLINE
| IFDEF IDENTIFIER NEWLINE
| IFNDEF IDENTIFIER NEWLINE
'''
if p.parser.enable_declaratives():
type = p.slice[1].type
if type == 'IF':
if p[2]:
result = p[2].evaluate(p.parser.namespace)
else:
# error
result = False
elif type == 'IFDEF':
result = p.parser.namespace.is_defined(p[2])
elif type == 'IFNDEF':
result = not p.parser.namespace.is_defined(p[2])
p.parser.write((create_token('PP_IFNDEF', p[2], p),))
else:
result = False
p.parser.condition_if(result)
def p_elif_groups_opt(self, p):
'''elif_groups_opt : elif_groups
|
'''
def p_elif_groups(self, p):
'''elif_groups : elif_group
| elif_groups elif_group
'''
def p_elif_group(self, p):
'''elif_group : elif_line group_opt
'''
def p_elif_line(self, p):
'''elif_line : ELIF replaced_elif_constant_expression NEWLINE
'''
result = p[2].evaluate(p.parser.namespace)
p.parser.condition_elif(result)
def p_else_group_opt(self, p):
'''else_group_opt : else_group
|
'''
def p_else_group(self, p):
'''else_group : else_line group_opt
'''
def p_else_line(self, p):
'''else_line : ELSE NEWLINE
'''
p.parser.condition_else()
def p_endif_line(self, p):
'''endif_line : ENDIF pp_tokens_opt NEWLINE
'''
# pp_tokens needed (ignored) here for Apple.
p.parser.condition_endif()
def p_control_line(self, p):
'''control_line : include_line NEWLINE
| define_object
| define_function
| undef_line
| LINE pp_tokens NEWLINE
| error_line
| PRAGMA pp_tokens_opt NEWLINE
'''
def p_include_line(self, p):
'''include_line : INCLUDE pp_tokens
| INCLUDE_NEXT pp_tokens
| IMPORT pp_tokens
'''
if p.parser.enable_declaratives():
tokens = p[2]
tokens = p.parser.namespace.apply_macros(tokens)
if len(tokens) > 0:
if p.slice[1].type == 'INCLUDE':
if tokens[0].type == 'STRING_LITERAL':
p.parser.include(tokens[0].value)
return
elif tokens[0].type == 'HEADER_NAME':
p.parser.include_system(tokens[0].value)
return
elif p.slice[1].type == 'INCLUDE_NEXT':
p.parser.include_next(tokens[0].value, p.slice[1].filename)
return
else:
if tokens[0].type == 'STRING_LITERAL':
p.parser.import_(tokens[0].value)
return
elif tokens[0].type == 'HEADER_NAME':
p.parser.import_system(tokens[0].value)
return
# TODO
print >> sys.stderr, 'Invalid #include'
def p_define_object(self, p):
'''define_object : DEFINE IDENTIFIER replacement_list NEWLINE
'''
if p.parser.enable_declaratives():
p.parser.namespace.define_object(p[2], p[3])
# Try to parse replacement list as an expression
tokens = p.parser.namespace.apply_macros(p[3])
lexer = TokenListLexer(tokens)
expr_parser = StrictConstantExpressionParser(lexer,
p.parser.namespace)
value = expr_parser.parse(debug=False)
if value is not None:
value = value.evaluate(p.parser.namespace)
p.parser.write(
(create_token('PP_DEFINE_CONSTANT', (p[2], value), p),))
else:
# Didn't parse, pass on as string
value = ' '.join([str(t.value) for t in p[3]])
p.parser.write((create_token('PP_DEFINE', (p[2], value), p),))
def p_define_function(self, p):
'''define_function : DEFINE IDENTIFIER LPAREN define_function_params ')' pp_tokens_opt NEWLINE
'''
if p.parser.enable_declaratives():
p.parser.namespace.define_function(p[2], p[4], p[6])
def p_define_function_params(self, p):
'''define_function_params : identifier_list_opt
| ELLIPSIS
| identifier_list ',' ELLIPSIS
'''
if len(p) == 2:
if p[1] == 'ELLIPSIS':
p[0] = ('...',)
else:
p[0] = p[1]
else:
p[0] = p[1] + ('...',)
def p_undef_line(self, p):
'''undef_line : UNDEF IDENTIFIER NEWLINE
'''
if p.parser.enable_declaratives():
p.parser.namespace.undef(p[2])
def p_error_line(self, p):
'''error_line : ERROR pp_tokens_opt NEWLINE
'''
if p.parser.enable_declaratives():
p.parser.error(' '.join([t.value for t in p[2]]),
p.slice[1].filename, p.slice[1].lineno)
def p_text_line(self, p):
'''text_line : pp_tokens_opt NEWLINE
'''
if p.parser.enable_declaratives():
tokens = p[1]
tokens = p.parser.namespace.apply_macros(tokens)
p.parser.write(tokens)
def p_replacement_list(self, p):
'''replacement_list :
| preprocessing_token_no_lparen
| preprocessing_token_no_lparen pp_tokens
'''
if len(p) == 3:
p[0] = (p[1],) + p[2]
elif len(p) == 2:
p[0] = (p[1],)
else:
p[0] = ()
def p_identifier_list_opt(self, p):
'''identifier_list_opt : identifier_list
|
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ()
def p_identifier_list(self, p):
'''identifier_list : IDENTIFIER
| identifier_list ',' IDENTIFIER
'''
if len(p) > 2:
p[0] = p[1] + (p[3],)
else:
p[0] = (p[1],)
def p_replaced_constant_expression(self, p):
'''replaced_constant_expression : pp_tokens'''
if p.parser.enable_conditionals():
tokens = p[1]
tokens = p.parser.namespace.apply_macros(tokens)
lexer = TokenListLexer(tokens)
parser = ConstantExpressionParser(lexer, p.parser.namespace)
p[0] = parser.parse(debug=True)
else:
p[0] = ConstantExpressionNode(0)
def p_replaced_elif_constant_expression(self, p):
'''replaced_elif_constant_expression : pp_tokens'''
if p.parser.enable_elif_conditionals():
tokens = p[1]
tokens = p.parser.namespace.apply_macros(tokens)
lexer = TokenListLexer(tokens)
parser = ConstantExpressionParser(lexer, p.parser.namespace)
p[0] = parser.parse(debug=True)
else:
p[0] = ConstantExpressionNode(0)
def p_pp_tokens_opt(self, p):
'''pp_tokens_opt : pp_tokens
|
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ()
def p_pp_tokens(self, p):
'''pp_tokens : preprocessing_token
| pp_tokens preprocessing_token
'''
if len(p) == 2:
p[0] = (p[1],)
else:
p[0] = p[1] + (p[2],)
def p_preprocessing_token_no_lparen(self, p):
'''preprocessing_token_no_lparen : HEADER_NAME
| IDENTIFIER
| PP_NUMBER
| CHARACTER_CONSTANT
| STRING_LITERAL
| punctuator
| DEFINED
| OTHER
'''
p[0] = symbol_to_token(p.slice[1])
def p_preprocessing_token(self, p):
'''preprocessing_token : preprocessing_token_no_lparen
| LPAREN
'''
p[0] = symbol_to_token(p.slice[1])
def p_punctuator(self, p):
'''punctuator : ELLIPSIS
| RIGHT_ASSIGN
| LEFT_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
| RIGHT_OP
| LEFT_OP
| INC_OP
| DEC_OP
| PTR_OP
| AND_OP
| OR_OP
| LE_OP
| GE_OP
| EQ_OP
| NE_OP
| HASH_HASH
| ';'
| '{'
| '}'
| ','
| ':'
| '='
| '('
| ')'
| '['
| ']'
| PERIOD
| '&'
| '!'
| '~'
| '-'
| '+'
| '*'
| '/'
| '%'
| '<'
| '>'
| '^'
| '|'
| '?'
| '#'
'''
p[0] = symbol_to_token(p.slice[1])
def p_error(self, t):
if not t:
# Crap, no way to get to Parser instance. FIXME TODO
print >> sys.stderr, 'Syntax error at end of file.'
else:
# TODO
print >> sys.stderr, '%s:%d Syntax error at %r' % \
(t.lexer.filename, t.lexer.lineno, t.value)
#t.lexer.cparser.handle_error('Syntax error at %r' % t.value,
# t.lexer.filename, t.lexer.lineno)
# Don't alter lexer: default behaviour is to pass error production
# up until it hits the catch-all at declaration, at which point
# parsing continues (synchronisation).
class ConstantExpressionParseException(Exception):
pass
class ConstantExpressionGrammar(Grammar):
name = 'expr'
tokens = tokens
def p_constant_expression(self, p):
'''constant_expression : conditional_expression
'''
p[0] = p[1]
p.parser.result = p[0]
def p_character_constant(self, p):
'''character_constant : CHARACTER_CONSTANT
'''
try:
value = ord(eval(p[1].lstrip('L')))
except StandardError:
value = 0
p[0] = ConstantExpressionNode(value)
def p_constant(self, p):
'''constant : PP_NUMBER
'''
value = p[1].rstrip('LlUu')
try:
if value[:2] == '0x':
value = int(value[2:], 16)
elif value[0] == '0':
value = int(value, 8)
else:
value = int(value)
except ValueError:
value = value.rstrip('eEfF')
try:
value = float(value)
except ValueError:
value = 0
p[0] = ConstantExpressionNode(value)
def p_identifier(self, p):
'''identifier : IDENTIFIER
'''
p[0] = ConstantExpressionNode(0)
def p_primary_expression(self, p):
'''primary_expression : constant
| character_constant
| identifier
| '(' expression ')'
| LPAREN expression ')'
'''
if p[1] == '(':
p[0] = p[2]
else:
p[0] = p[1]
def p_postfix_expression(self, p):
'''postfix_expression : primary_expression
'''
p[0] = p[1]
def p_unary_expression(self, p):
'''unary_expression : postfix_expression
| unary_operator cast_expression
'''
if len(p) == 2:
p[0] = p[1]
elif type(p[1]) == tuple:
# unary_operator reduces to (op, op_str)
p[0] = UnaryExpressionNode(p[1][0], p[1][1], p[2])
else:
# TODO
p[0] = None
def p_unary_operator(self, p):
'''unary_operator : '+'
| '-'
| '~'
| '!'
'''
# reduces to (op, op_str)
p[0] = ({
'+': operator.pos,
'-': operator.neg,
'~': operator.inv,
'!': operator.not_}[p[1]], p[1])
def p_cast_expression(self, p):
'''cast_expression : unary_expression
'''
p[0] = p[len(p) - 1]
def p_multiplicative_expression(self, p):
'''multiplicative_expression : cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'*': operator.mul,
'/': operator.div,
'%': operator.mod}[p[2]], p[2], p[1], p[3])
def p_additive_expression(self, p):
'''additive_expression : multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'+': operator.add,
'-': operator.sub}[p[2]], p[2], p[1], p[3])
def p_shift_expression(self, p):
'''shift_expression : additive_expression
| shift_expression LEFT_OP additive_expression
| shift_expression RIGHT_OP additive_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'<<': operator.lshift,
'>>': operator.rshift}[p[2]], p[2], p[1], p[3])
def p_relational_expression(self, p):
'''relational_expression : shift_expression
| relational_expression '<' shift_expression
| relational_expression '>' shift_expression
| relational_expression LE_OP shift_expression
| relational_expression GE_OP shift_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'>': operator.gt,
'<': operator.lt,
'<=': operator.le,
'>=': operator.ge}[p[2]], p[2], p[1], p[3])
def p_equality_expression(self, p):
'''equality_expression : relational_expression
| equality_expression EQ_OP relational_expression
| equality_expression NE_OP relational_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'==': operator.eq,
'!=': operator.ne}[p[2]], p[2], p[1], p[3])
def p_and_expression(self, p):
'''and_expression : equality_expression
| and_expression '&' equality_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.and_, '&', p[1], p[3])
def p_exclusive_or_expression(self, p):
'''exclusive_or_expression : and_expression
| exclusive_or_expression '^' and_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.xor, '^', p[1], p[3])
def p_inclusive_or_expression(self, p):
'''inclusive_or_expression : exclusive_or_expression
| inclusive_or_expression '|' exclusive_or_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.or_, '|', p[1], p[3])
def p_logical_and_expression(self, p):
'''logical_and_expression : inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = LogicalAndExpressionNode(p[1], p[3])
def p_logical_or_expression(self, p):
'''logical_or_expression : logical_and_expression
| logical_or_expression OR_OP logical_and_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = LogicalOrExpressionNode(p[1], p[3])
def p_conditional_expression(self, p):
'''conditional_expression : logical_or_expression
| logical_or_expression '?' expression ':' conditional_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ConditionalExpressionNode(p[1], p[3], p[5])
def p_assignment_expression(self, p):
'''assignment_expression : conditional_expression
| unary_expression assignment_operator assignment_expression
'''
# TODO assignment
if len(p) == 2:
p[0] = p[1]
def p_assignment_operator(self, p):
'''assignment_operator : '='
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| LEFT_ASSIGN
| RIGHT_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
'''
def p_expression(self, p):
'''expression : assignment_expression
| expression ',' assignment_expression
'''
# TODO sequence
if len(p) == 2:
p[0] = p[1]
def p_error(self, t):
raise ConstantExpressionParseException()
class StrictConstantExpressionGrammar(ConstantExpressionGrammar):
name = 'strict_expr'
tokens = tokens
def p_identifier(self, p):
'''identifier : IDENTIFIER
'''
raise ConstantExpressionParseException()
class ExecutionState(object):
def __init__(self, parent_enabled, enabled):
self.enabled = parent_enabled and enabled
self.context_enabled = enabled
self.parent_enabled = parent_enabled
def enable(self, result):
if result:
self.enabled = self.parent_enabled and not self.context_enabled
self.context_enabled = True
else:
self.enabled = False
class PreprocessorParser(yacc.Parser):
def __init__(self, gcc_search_path=True):
yacc.Parser.__init__(self)
self.lexer = lex.lex(cls=PreprocessorLexer)
PreprocessorGrammar.get_prototype().init_parser(self)
# Map system header name to data, overrides path search and open()
self.system_headers = {}
self.include_path = ['/usr/local/include', '/usr/include']
if sys.platform == 'darwin':
self.framework_path = ['/System/Library/Frameworks',
'/Library/Frameworks']
else:
self.framework_path = []
if gcc_search_path:
self.add_gcc_search_path()
self.lexer.filename = ''
self.defines = {}
self.namespace = PreprocessorNamespace()
def define(self, name, value):
self.defines[name] = value
def add_gcc_search_path(self):
from subprocess import Popen, PIPE
path = Popen('gcc -print-file-name=include',
shell=True, stdout=PIPE).communicate()[0].strip()
if path:
self.include_path.append(path)
def parse(self, filename=None, data=None, namespace=None, debug=False):
self.output = []
if not namespace:
namespace = self.namespace
for name, value in self.defines.items():
namespace.define_object(name, (create_token('IDENTIFIER', value),))
self.namespace = namespace
self.imported_headers = set()
self.condition_stack = [ExecutionState(True, True)]
if filename:
if not data:
data = open(filename, 'r').read()
self.lexer.input(data, filename)
elif data:
self.lexer.input(data, '<input>')
return yacc.Parser.parse(self, debug=debug)
def push_file(self, filename, data=None):
print >> sys.stderr, filename
if not data:
data = open(filename).read()
self.lexer.push_input(data, filename)
def include(self, header):
path = self.get_header_path(header)
if path:
self.push_file(path)
else:
print >> sys.stderr, '"%s" not found' % header # TODO
def include_system(self, header):
if header in self.system_headers:
self.push_file(header, self.system_headers[header])
return
path = self.get_system_header_path(header)
if path:
self.push_file(path)
else:
print >> sys.stderr, '"%s" not found' % header # TODO
def include_next(self, header, reference):
# XXX doesn't go via get_system_header
next = False
for path in self.include_path:
p = os.path.join(path, header)
if os.path.exists(p):
if next:
self.push_file(p)
return
elif p == reference:
next = True
print >> sys.stderr, '%s: cannot include_next from %s' % \
(header, reference) # TODO
def import_(self, header):
path = self.get_header_path(header)
if path:
if path not in self.imported_headers:
self.imported_headers.add(path)
self.push_file(path)
else:
print >> sys.stderr, '"%s" not found' % header # TODO
def import_system(self, header):
if header in self.system_headers:
if path not in self.imported_headers:
self.imported_headers.add(path)
self.push_file(header, self.system_headers[header])
return
path = self.get_system_header_path(header)
if path:
if path not in self.imported_headers:
self.imported_headers.add(path)
self.push_file(path)
else:
print >> sys.stderr, '"%s" not found' % header # TODO
def get_header_path(self, header):
p = os.path.join(os.path.dirname(self.lexer.filename), header)
if os.path.exists(p):
self.push_file(p)
return p
elif sys.platform == 'darwin':
p = self.get_framework_header_path(header)
if not p:
p = self.get_system_header_path(header)
return p
def get_system_header_path(self, header):
for path in self.include_path:
p = os.path.join(path, header)
if os.path.exists(p):
return p
if sys.platform == 'darwin':
return self.get_framework_header_path(header)
def get_framework_header_path(self, header):
if '/' in header:
# header is 'Framework/Framework.h' (e.g. OpenGL/OpenGL.h).
framework, header = header.split('/', 1)
paths = self.framework_path[:]
# Add ancestor frameworks of current file
localpath = ''
for parent in self.lexer.filename.split('.framework/')[:-1]:
localpath += parent + '.framework'
paths.append(os.path.join(localpath, 'Frameworks'))
for path in paths:
p = os.path.join(path, '%s.framework' % framework,
'Headers', header)
if os.path.exists(p):
return p
def error(self, message, filename, line):
print >> sys.stderr, '%s:%d #error %s' % (filename, line, message)
def condition_if(self, result):
self.condition_stack.append(
ExecutionState(self.condition_stack[-1].enabled, result))
def condition_elif(self, result):
self.condition_stack[-1].enable(result)
def condition_else(self):
self.condition_stack[-1].enable(True)
def condition_endif(self):
self.condition_stack.pop()
def enable_declaratives(self):
return self.condition_stack[-1].enabled
def enable_conditionals(self):
return self.condition_stack[-1].enabled
def enable_elif_conditionals(self):
return self.condition_stack[-1].parent_enabled and \
not self.condition_stack[-1].context_enabled
def write(self, tokens):
for t in tokens:
if t.type == 'HEADER_NAME':
# token was mis-parsed. Do it again, without the '<', '>'.
ta = create_token('<', '<')
ta.filename = t.filename
ta.lineno = t.lineno
self.output.append(ta)
l = lex.lex(cls=PreprocessorLexer)
l.input(t.value, t.filename)
l.lineno = t.lineno
tb = l.token()
while tb is not None:
if hasattr(tb, 'lexer'):
del tb.lexer
self.output.append(tb)
tb = l.token()
tc = create_token('>', '>')
tc.filename = t.filename
tc.lineno = t.lineno
self.output.append(tc)
continue
if hasattr(t, 'lexer'):
del t.lexer
self.output.append(t)
def get_memento(self):
return (set(self.namespace.objects.keys()),
set(self.namespace.functions.keys()))
class ConstantExpressionParser(yacc.Parser):
_const_grammar = ConstantExpressionGrammar
def __init__(self, lexer, namespace):
yacc.Parser.__init__(self)
self.lexer = lexer
self.namespace = namespace
self._const_grammar.get_prototype().init_parser(self)
def parse(self, debug=False):
self.result = None
try:
yacc.Parser.parse(self, lexer=self.lexer, debug=debug)
except ConstantExpressionParseException:
# XXX warning here?
pass
return self.result
class StrictConstantExpressionParser(ConstantExpressionParser):
_const_grammar = StrictConstantExpressionGrammar
class PreprocessorNamespace(EvaluationContext):
def __init__(self, gcc_macros=True,
stdc_macros=True,
workaround_macros=True):
self.objects = {}
self.functions = {}
if stdc_macros:
self.add_stdc_macros()
if gcc_macros:
self.add_gcc_macros()
if workaround_macros:
self.add_workaround_macros()
def add_stdc_macros(self):
'''Add macros defined in 6.10.8 except __FILE__ and __LINE__.
This is potentially dangerous, as this preprocessor is not ISO
compliant in many ways (the most obvious is the lack of # and ##
operators). It is required for Apple headers, however, which
otherwise assume some truly bizarre syntax is ok.
'''
import time
date = time.strftime('%b %d %Y') # XXX %d should have leading space
t = time.strftime('%H:%M:S')
self.define_object('__DATE__',
(create_token('STRING_LITERAL', date),))
self.define_object('__TIME__',
(create_token('STRING_LITERAL', t),))
self.define_object('__STDC__',
(create_token('PP_NUMBER', '1'),))
self.define_object('__STDC_HOSTED__',
(create_token('PP_NUMBER', '1'),))
self.define_object('__STDC_VERSION',
(create_token('PP_NUMBER', '199901L'),))
def add_gcc_macros(self):
import platform
import sys
gcc_macros = ('__GLIBC_HAVE_LONG_LONG', '__GNUC__',)
# Get these from `gcc -E -dD empty.c`
machine_macros = {
'x86_64': ('__amd64', '__amd64__', '__x86_64', '__x86_64__',
'__tune_k8__', '__MMX__', '__SSE__', '__SSE2__',
'__SSE_MATH__', '__k8', '__k8__'),
'Power Macintosh': ('_ARCH_PPC', '__BIG_ENDIAN__', '_BIG_ENDIAN',
'__ppc__', '__POWERPC__'),
# TODO everyone else.
}.get(platform.machine(), ())
platform_macros = {
'linux': ('__gnu_linux__', '__linux', '__linux__', 'linux',
'__unix', '__unix__', 'unix'),
'linux2': ('__gnu_linux__', '__linux', '__linux__', 'linux',
'__unix', '__unix__', 'unix'),
'linux3': ('__gnu_linux__', '__linux', '__linux__', 'linux',
'__unix', '__unix__', 'unix'),
'darwin': ('__MACH__', '__APPLE__', '__DYNAMIC__', '__APPLE_CC__'),
'win32': ('_WIN32',),
# TODO everyone else
}.get(sys.platform, ())
tok1 = lex.LexToken()
tok1.type = 'PP_NUMBER'
tok1.value = '1'
tok1.lineno = -1
tok1.lexpos = -1
for macro in machine_macros + platform_macros + gcc_macros:
self.define_object(macro, (tok1,))
self.define_object('inline', ())
self.define_object('__inline', ())
self.define_object('__inline__', ())
self.define_object('__const', (create_token('IDENTIFIER', 'const'),))
def add_workaround_macros(self):
if sys.platform == 'darwin':
self.define_object('CF_INLINE', ())
def is_defined(self, name):
return name in self.objects or name in self.functions
def undef(self, name):
if name in self.objects:
del self.objects[name]
if name in self.functions:
del self.functions[name]
def define_object(self, name, replacements):
# TODO check not already existing in objects or functions
for r in replacements:
if hasattr(r, 'lexer'):
del r.lexer
self.objects[name] = replacements
def define_function(self, name, params, replacements):
# TODO check not already existing in objects or functions
for r in replacements:
if hasattr(r, 'lexer'):
del r.lexer
replacements = list(replacements)
params = list(params)
numargs = len(params)
for i, t in enumerate(replacements):
if hasattr(t, 'lexer'):
del t.lexer
if t.type == 'IDENTIFIER' and t.value in params:
replacements[i] = params.index(t.value)
elif t.type == 'IDENTIFIER' and t.value == '__VA_ARGS__' and \
'...' in params:
replacements[i] = len(params) - 1
self.functions[name] = replacements, numargs
def apply_macros(self, tokens, replacing=None):
repl = []
i = 0
while i < len(tokens):
token = tokens[i]
if token.type == 'IDENTIFIER' and token.value in self.objects:
r = self.objects[token.value]
if token.value != replacing and r:
repl += self.apply_macros(r, token.value)
elif token.type == 'IDENTIFIER' and \
token.value in self.functions and \
len(tokens) - i > 2 and \
tokens[i+1].value == '(':
r, numargs = self.functions[token.value][:]
# build params list
i += 2
params = [[]]
parens = 0 # balance parantheses within each arg
while i < len(tokens):
if tokens[i].value == ',' and parens == 0 and \
len(params) < numargs:
params.append([])
elif tokens[i].value == ')' and parens == 0:
break
else:
if tokens[i].value == '(':
parens += 1
elif tokens[i].value == ')':
parens -= 1
params[-1].append(tokens[i])
i += 1
if token.value != replacing and r:
newr = []
for t in r:
if type(t) == int:
newr += params[t]
else:
newr.append(t)
repl += self.apply_macros(newr, token.value)
elif token.type == 'DEFINED':
if len(tokens) - i > 3 and \
tokens[i + 1].type in ('(', 'LPAREN') and \
tokens[i + 2].type == 'IDENTIFIER' and \
tokens[i + 3].type == ')':
result = self.is_defined(tokens[i + 2].value)
i += 3
elif len(tokens) - i > 1 and \
tokens[i + 1].type == 'IDENTIFIER':
result = self.is_defined(tokens[i + 1].value)
i += 1
else:
# TODO
print >> sys.stderr, 'Invalid use of "defined"'
result = 0
t = lex.LexToken()
t.value = str(int(result))
t.type = 'PP_NUMBER'
t.lexpos = token.lexpos
t.lineno = token.lineno
repl.append(t)
else:
repl.append(token)
i += 1
return repl
def copy(self):
n = PreprocessorNamespace(gcc_macros=False, workaround_macros=False)
n.functions = self.functions.copy()
n.objects = self.objects.copy()
return n
if __name__ == '__main__':
filename = sys.argv[1]
parser = PreprocessorParser()
parser.parse(filename, debug=True)
print ' '.join([str(t.value) for t in parser.output])
| Python |
#!/usr/bin/env python
'''Parse a C source file.
To use, subclass CParser and override its handle_* methods. Then instantiate
the class with a string to parse.
Derived from ANSI C grammar:
* Lexicon: http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
* Grammar: http://www.lysator.liu.se/c/ANSI-C-grammar-y.html
Reference is C99:
* http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import cPickle
import operator
import os.path
import re
import sys
import time
import warnings
import preprocessor
import yacc
tokens = (
'PP_IF', 'PP_IFDEF', 'PP_IFNDEF', 'PP_ELIF', 'PP_ELSE',
'PP_ENDIF', 'PP_INCLUDE', 'PP_DEFINE', 'PP_DEFINE_CONSTANT', 'PP_UNDEF',
'PP_LINE', 'PP_ERROR', 'PP_PRAGMA',
'IDENTIFIER', 'CONSTANT', 'CHARACTER_CONSTANT', 'STRING_LITERAL', 'SIZEOF',
'PTR_OP', 'INC_OP', 'DEC_OP', 'LEFT_OP', 'RIGHT_OP', 'LE_OP', 'GE_OP',
'EQ_OP', 'NE_OP', 'AND_OP', 'OR_OP', 'MUL_ASSIGN', 'DIV_ASSIGN',
'MOD_ASSIGN', 'ADD_ASSIGN', 'SUB_ASSIGN', 'LEFT_ASSIGN', 'RIGHT_ASSIGN',
'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN', 'HASH_HASH', 'PERIOD',
'TYPE_NAME',
'TYPEDEF', 'EXTERN', 'STATIC', 'AUTO', 'REGISTER',
'CHAR', 'SHORT', 'INT', 'LONG', 'SIGNED', 'UNSIGNED', 'FLOAT', 'DOUBLE',
'CONST', 'VOLATILE', 'VOID',
'STRUCT', 'UNION', 'ENUM', 'ELLIPSIS',
'CASE', 'DEFAULT', 'IF', 'ELSE', 'SWITCH', 'WHILE', 'DO', 'FOR', 'GOTO',
'CONTINUE', 'BREAK', 'RETURN', '__ASM__'
)
keywords = [
'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'int',
'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static',
'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile',
'while', '__asm__'
]
# --------------------------------------------------------------------------
# C Object Model
# --------------------------------------------------------------------------
class Declaration(object):
def __init__(self):
self.declarator = None
self.type = Type()
self.storage = None
def __repr__(self):
d = {
'declarator': self.declarator,
'type': self.type,
}
if self.storage:
d['storage'] = self.storage
l = ['%s=%r' % (k, v) for k, v in d.items()]
return 'Declaration(%s)' % ', '.join(l)
class Declarator(object):
pointer = None
def __init__(self):
self.identifier = None
self.initializer = None
self.array = None
self.parameters = None
# make pointer read-only to catch mistakes early
pointer = property(lambda self: None)
def __repr__(self):
s = self.identifier or ''
if self.array:
s += repr(self.array)
if self.initializer:
s += ' = %r' % self.initializer
if self.parameters is not None:
s += '(' + ', '.join([repr(p) for p in self.parameters]) + ')'
return s
class Pointer(Declarator):
pointer = None
def __init__(self):
super(Pointer, self).__init__()
self.qualifiers = []
def __repr__(self):
q = ''
if self.qualifiers:
q = '<%s>' % ' '.join(self.qualifiers)
return 'POINTER%s(%r)' % (q, self.pointer) + \
super(Pointer, self).__repr__()
class Array(object):
def __init__(self):
self.size = None
self.array = None
def __repr__(self):
if self.size:
a = '[%r]' % self.size
else:
a = '[]'
if self.array:
return repr(self.array) + a
else:
return a
class Parameter(object):
def __init__(self):
self.type = Type()
self.storage = None
self.declarator = None
def __repr__(self):
d = {
'type': self.type,
}
if self.declarator:
d['declarator'] = self.declarator
if self.storage:
d['storage'] = self.storage
l = ['%s=%r' % (k, v) for k, v in d.items()]
return 'Parameter(%s)' % ', '.join(l)
class Type(object):
def __init__(self):
self.qualifiers = []
self.specifiers = []
def __repr__(self):
return ' '.join(self.qualifiers + [str(s) for s in self.specifiers])
# These are used only internally.
class StorageClassSpecifier(str):
pass
class TypeSpecifier(str):
pass
class StructTypeSpecifier(object):
def __init__(self, is_union, tag, declarations):
self.is_union = is_union
self.tag = tag
self.declarations = declarations
def __repr__(self):
if self.is_union:
s = 'union'
else:
s = 'struct'
if self.tag:
s += ' %s' % self.tag
if self.declarations:
s += ' {%s}' % '; '.join([repr(d) for d in self.declarations])
return s
class EnumSpecifier(object):
def __init__(self, tag, enumerators):
self.tag = tag
self.enumerators = enumerators
def __repr__(self):
s = 'enum'
if self.tag:
s += ' %s' % self.tag
if self.enumerators:
s += ' {%s}' % ', '.join([repr(e) for e in self.enumerators])
return s
class Enumerator(object):
def __init__(self, name, expression):
self.name = name
self.expression = expression
def __repr__(self):
s = self.name
if self.expression:
s += ' = %r' % self.expression
return s
class TypeQualifier(str):
pass
def apply_specifiers(specifiers, declaration):
'''Apply specifiers to the declaration (declaration may be
a Parameter instead).'''
for s in specifiers:
if type(s) == StorageClassSpecifier:
if declaration.storage:
p.parser.cparser.handle_error(
'Declaration has more than one storage class',
'???', p.lineno(1))
return
declaration.storage = s
elif type(s) in (TypeSpecifier, StructTypeSpecifier, EnumSpecifier):
declaration.type.specifiers.append(s)
elif type(s) == TypeQualifier:
declaration.type.qualifiers.append(s)
# --------------------------------------------------------------------------
# Expression Object Model
# --------------------------------------------------------------------------
class EvaluationContext(object):
'''Interface for evaluating expression nodes.
'''
def evaluate_identifier(self, name):
warnings.warn('Attempt to evaluate identifier "%s" failed' % name)
return 0
def evaluate_sizeof(self, type):
warnings.warn('Attempt to evaluate sizeof "%s" failed' % str(type))
return 0
class ExpressionNode(object):
def evaluate(self, context):
return 0
def __str__(self):
return ''
class ConstantExpressionNode(ExpressionNode):
def __init__(self, value):
self.value = value
def evaluate(self, context):
return self.value
def __str__(self):
return str(self.value)
class IdentifierExpressionNode(ExpressionNode):
def __init__(self, name):
self.name = name
def evaluate(self, context):
return context.evaluate_identifier(self.name)
def __str__(self):
return str(self.value)
class UnaryExpressionNode(ExpressionNode):
def __init__(self, op, op_str, child):
self.op = op
self.op_str = op_str
self.child = child
def evaluate(self, context):
return self.op(self.child.evaluate(context))
def __str__(self):
return '(%s %s)' % (self.op_str, self.child)
class SizeOfExpressionNode(ExpressionNode):
def __init__(self, type):
self.type = type
def evaluate(self, context):
return context.evaluate_sizeof(self.type)
def __str__(self):
return 'sizeof(%s)' % str(self.type)
class BinaryExpressionNode(ExpressionNode):
def __init__(self, op, op_str, left, right):
self.op = op
self.op_str = op_str
self.left = left
self.right = right
def evaluate(self, context):
return self.op(self.left.evaluate(context),
self.right.evaluate(context))
def __str__(self):
return '(%s %s %s)' % (self.left, self.op_str, self.right)
class LogicalAndExpressionNode(ExpressionNode):
def __init__(self, left, right):
self.left = left
self.right = right
def evaluate(self, context):
return self.left.evaluate(context) and self.right.evaluate(context)
def __str__(self):
return '(%s && %s)' % (self.left, self.right)
class LogicalOrExpressionNode(ExpressionNode):
def __init__(self, left, right):
self.left = left
self.right = right
def evaluate(self, context):
return self.left.evaluate(context) or self.right.evaluate(context)
def __str__(self):
return '(%s || %s)' % (self.left, self.right)
class ConditionalExpressionNode(ExpressionNode):
def __init__(self, condition, left, right):
self.condition = condition
self.left = left
self.right = right
def evaluate(self, context):
if self.condition.evaluate(context):
return self.left.evaluate(context)
else:
return self.right.evaluate(context)
def __str__(self):
return '(%s ? %s : %s)' % (self.condition, self.left, self.right)
# --------------------------------------------------------------------------
# Grammar
# --------------------------------------------------------------------------
def p_translation_unit(p):
'''translation_unit :
| translation_unit external_declaration
'''
# Starting production.
# Allow empty production so that files with no declarations are still
# valid.
# Intentionally empty
def p_identifier(p):
'''identifier : IDENTIFIER'''
p[0] = IdentifierExpressionNode(p[1])
def p_constant(p):
'''constant : CONSTANT
| CHARACTER_CONSTANT
'''
def _to_int(s):
if s.startswith('0x'):
return int(s, base=16)
elif s.startswith('0'):
return int(s, base=8)
else:
return int(s)
value = p[1]
try:
value = _to_int(value)
except ValueError:
pass
p[0] = ConstantExpressionNode(value)
def p_string_literal(p):
'''string_literal : STRING_LITERAL'''
p[0] = ConstantExpressionNode(p[1])
def p_primary_expression(p):
'''primary_expression : identifier
| constant
| string_literal
| '(' expression ')'
'''
if p[1] == '(':
p[0] = p[2]
else:
p[0] = p[1]
def p_postfix_expression(p):
'''postfix_expression : primary_expression
| postfix_expression '[' expression ']'
| postfix_expression '(' ')'
| postfix_expression '(' argument_expression_list ')'
| postfix_expression PERIOD IDENTIFIER
| postfix_expression PTR_OP IDENTIFIER
| postfix_expression INC_OP
| postfix_expression DEC_OP
'''
# XXX Largely unsupported
p[0] = p[1]
def p_argument_expression_list(p):
'''argument_expression_list : assignment_expression
| argument_expression_list ',' assignment_expression
'''
def p_asm_expression(p):
'''asm_expression : __ASM__ volatile_opt '(' string_literal ')'
| __ASM__ volatile_opt '(' string_literal ':' str_opt_expr_pair_list ')'
| __ASM__ volatile_opt '(' string_literal ':' str_opt_expr_pair_list ':' str_opt_expr_pair_list ')'
| __ASM__ volatile_opt '(' string_literal ':' str_opt_expr_pair_list ':' str_opt_expr_pair_list ':' str_opt_expr_pair_list ')'
'''
# Definitely not ISO C, adapted from example ANTLR GCC parser at
# http://www.antlr.org/grammar/cgram//grammars/GnuCParser.g
# but more lenient (expressions permitted in optional final part, when
# they shouldn't be -- avoids shift/reduce conflict with
# str_opt_expr_pair_list).
# XXX node not supported
p[0] = ExpressionNode()
def p_str_opt_expr_pair_list(p):
'''str_opt_expr_pair_list :
| str_opt_expr_pair
| str_opt_expr_pair_list ',' str_opt_expr_pair
'''
def p_str_opt_expr_pair(p):
'''str_opt_expr_pair : string_literal
| string_literal '(' expression ')'
'''
def p_volatile_opt(p):
'''volatile_opt :
| VOLATILE
'''
def p_unary_expression(p):
'''unary_expression : postfix_expression
| INC_OP unary_expression
| DEC_OP unary_expression
| unary_operator cast_expression
| SIZEOF unary_expression
| SIZEOF '(' type_name ')'
| asm_expression
'''
if len(p) == 2:
p[0] = p[1]
elif p[1] == 'sizeof':
if p[2] == '(':
p[0] = SizeOfExpressionNode(p[3])
else:
p[0] = SizeOfExpressionNode(p[2])
elif type(p[1]) == tuple:
# unary_operator reduces to (op, op_str)
p[0] = UnaryExpressionNode(p[1][0], p[1][1], p[2])
else:
# XXX INC_OP and DEC_OP expression nodes not supported
p[0] = p[2]
def p_unary_operator(p):
'''unary_operator : '&'
| '*'
| '+'
| '-'
| '~'
| '!'
'''
# reduces to (op, op_str)
p[0] = ({
'+': operator.pos,
'-': operator.neg,
'~': operator.inv,
'!': operator.not_,
'&': 'AddressOfUnaryOperator',
'*': 'DereferenceUnaryOperator'}[p[1]], p[1])
def p_cast_expression(p):
'''cast_expression : unary_expression
| '(' type_name ')' cast_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
# XXX cast node not supported
p[0] = p[4]
def p_multiplicative_expression(p):
'''multiplicative_expression : cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'*': operator.mul,
'/': operator.div,
'%': operator.mod}[p[2]], p[2], p[1], p[3])
def p_additive_expression(p):
'''additive_expression : multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'+': operator.add,
'-': operator.sub}[p[2]], p[2], p[1], p[3])
def p_shift_expression(p):
'''shift_expression : additive_expression
| shift_expression LEFT_OP additive_expression
| shift_expression RIGHT_OP additive_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'<<': operator.lshift,
'>>': operator.rshift}[p[2]], p[2], p[1], p[3])
def p_relational_expression(p):
'''relational_expression : shift_expression
| relational_expression '<' shift_expression
| relational_expression '>' shift_expression
| relational_expression LE_OP shift_expression
| relational_expression GE_OP shift_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'>': operator.gt,
'<': operator.lt,
'<=': operator.le,
'>=': operator.ge}[p[2]], p[2], p[1], p[3])
def p_equality_expression(p):
'''equality_expression : relational_expression
| equality_expression EQ_OP relational_expression
| equality_expression NE_OP relational_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode({
'==': operator.eq,
'!=': operator.ne}[p[2]], p[2], p[1], p[3])
def p_and_expression(p):
'''and_expression : equality_expression
| and_expression '&' equality_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.and_, '&', p[1], p[3])
def p_exclusive_or_expression(p):
'''exclusive_or_expression : and_expression
| exclusive_or_expression '^' and_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.xor, '^', p[1], p[3])
def p_inclusive_or_expression(p):
'''inclusive_or_expression : exclusive_or_expression
| inclusive_or_expression '|' exclusive_or_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = BinaryExpressionNode(operator.or_, '|', p[1], p[3])
def p_logical_and_expression(p):
'''logical_and_expression : inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = LogicalAndExpressionNode(p[1], p[3])
def p_logical_or_expression(p):
'''logical_or_expression : logical_and_expression
| logical_or_expression OR_OP logical_and_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = LogicalOrExpressionNode(p[1], p[3])
def p_conditional_expression(p):
'''conditional_expression : logical_or_expression
| logical_or_expression '?' expression ':' conditional_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ConditionalExpressionNode(p[1], p[3], p[5])
def p_assignment_expression(p):
'''assignment_expression : conditional_expression
| unary_expression assignment_operator assignment_expression
'''
if len(p) == 2:
p[0] = p[1]
else:
# XXX assignment expression node not supported
p[0] = p[3]
def p_assignment_operator(p):
'''assignment_operator : '='
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| LEFT_ASSIGN
| RIGHT_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
'''
def p_expression(p):
'''expression : assignment_expression
| expression ',' assignment_expression
'''
p[0] = p[1]
# XXX sequence expression node not supported
def p_constant_expression(p):
'''constant_expression : conditional_expression
'''
p[0] = p[1]
def p_declaration(p):
'''declaration : declaration_impl ';'
'''
# The ';' must be here, not in 'declaration', as declaration needs to
# be executed before the ';' is shifted (otherwise the next lookahead will
# be read, which may be affected by this declaration if its a typedef.
def p_declaration_impl(p):
'''declaration_impl : declaration_specifiers
| declaration_specifiers init_declarator_list
'''
declaration = Declaration()
apply_specifiers(p[1], declaration)
if len(p) == 2:
filename = p.slice[1].filename
lineno = p.slice[1].lineno
p.parser.cparser.impl_handle_declaration(declaration, filename, lineno)
return
filename = p.slice[2].filename
lineno = p.slice[2].lineno
for declarator in p[2]:
declaration.declarator = declarator
p.parser.cparser.impl_handle_declaration(declaration, filename, lineno)
""" # shift/reduce conflict with p_statement_error.
def p_declaration_error(p):
'''declaration : error ';'
'''
# Error resynchronisation catch-all
"""
def p_declaration_specifiers(p):
'''declaration_specifiers : storage_class_specifier
| storage_class_specifier declaration_specifiers
| type_specifier
| type_specifier declaration_specifiers
| type_qualifier
| type_qualifier declaration_specifiers
'''
if len(p) > 2:
p[0] = (p[1],) + p[2]
else:
p[0] = (p[1],)
def p_init_declarator_list(p):
'''init_declarator_list : init_declarator
| init_declarator_list ',' init_declarator
'''
if len(p) > 2:
p[0] = p[1] + (p[3],)
else:
p[0] = (p[1],)
def p_init_declarator(p):
'''init_declarator : declarator
| declarator '=' initializer
'''
p[0] = p[1]
if len(p) > 2:
p[0].initializer = p[2]
def p_storage_class_specifier(p):
'''storage_class_specifier : TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
'''
p[0] = StorageClassSpecifier(p[1])
def p_type_specifier(p):
'''type_specifier : VOID
| CHAR
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
| SIGNED
| UNSIGNED
| struct_or_union_specifier
| enum_specifier
| TYPE_NAME
'''
if type(p[1]) in (StructTypeSpecifier, EnumSpecifier):
p[0] = p[1]
else:
p[0] = TypeSpecifier(p[1])
# TODO enum
def p_struct_or_union_specifier(p):
'''struct_or_union_specifier : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
| struct_or_union TYPE_NAME '{' struct_declaration_list '}'
| struct_or_union '{' struct_declaration_list '}'
| struct_or_union IDENTIFIER
| struct_or_union TYPE_NAME
'''
# The TYPE_NAME ones are dodgy, needed for Apple headers
# CoreServices.framework/Frameworks/CarbonCore.framework/Headers/Files.h.
# CoreServices.framework/Frameworks/OSServices.framework/Headers/Power.h
if len(p) == 3:
p[0] = StructTypeSpecifier(p[1], p[2], None)
elif p[2] == '{':
p[0] = StructTypeSpecifier(p[1], '', p[3])
else:
p[0] = StructTypeSpecifier(p[1], p[2], p[4])
def p_struct_or_union(p):
'''struct_or_union : STRUCT
| UNION
'''
p[0] = p[1] == 'union'
def p_struct_declaration_list(p):
'''struct_declaration_list : struct_declaration
| struct_declaration_list struct_declaration
'''
if len(p) == 2:
p[0] = p[1]
else:
p[0] = p[1] + p[2]
def p_struct_declaration(p):
'''struct_declaration : specifier_qualifier_list struct_declarator_list ';'
'''
# p[0] returned is a tuple, to handle multiple declarators in one
# declaration.
r = ()
for declarator in p[2]:
declaration = Declaration()
apply_specifiers(p[1], declaration)
declaration.declarator = declarator
r += (declaration,)
p[0] = r
def p_specifier_qualifier_list(p):
'''specifier_qualifier_list : type_specifier specifier_qualifier_list
| type_specifier
| type_qualifier specifier_qualifier_list
| type_qualifier
'''
# XXX Interesting.. why is this one right-recursion?
if len(p) == 3:
p[0] = (p[1],) + p[2]
else:
p[0] = (p[1],)
def p_struct_declarator_list(p):
'''struct_declarator_list : struct_declarator
| struct_declarator_list ',' struct_declarator
'''
if len(p) == 2:
p[0] = (p[1],)
else:
p[0] = p[1] + (p[3],)
def p_struct_declarator(p):
'''struct_declarator : declarator
| ':' constant_expression
| declarator ':' constant_expression
'''
# XXX ignoring bitfields.
if p[1] == ':':
p[0] = Declarator()
else:
p[0] = p[1]
def p_enum_specifier(p):
'''enum_specifier : ENUM '{' enumerator_list '}'
| ENUM IDENTIFIER '{' enumerator_list '}'
| ENUM IDENTIFIER
'''
if len(p) == 5:
p[0] = EnumSpecifier(None, p[3])
elif len(p) == 6:
p[0] = EnumSpecifier(p[2], p[4])
else:
p[0] = EnumSpecifier(p[2], ())
def p_enumerator_list(p):
'''enumerator_list : enumerator_list_iso
| enumerator_list_iso ','
'''
# Apple headers sometimes have trailing ',' after enumerants, which is
# not ISO C.
p[0] = p[1]
def p_enumerator_list_iso(p):
'''enumerator_list_iso : enumerator
| enumerator_list_iso ',' enumerator
'''
if len(p) == 2:
p[0] = (p[1],)
else:
p[0] = p[1] + (p[3],)
def p_enumerator(p):
'''enumerator : IDENTIFIER
| IDENTIFIER '=' constant_expression
'''
if len(p) == 2:
p[0] = Enumerator(p[1], None)
else:
p[0] = Enumerator(p[1], p[3])
def p_type_qualifier(p):
'''type_qualifier : CONST
| VOLATILE
'''
p[0] = TypeQualifier(p[1])
def p_declarator(p):
'''declarator : pointer direct_declarator
| direct_declarator
'''
if len(p) > 2:
p[0] = p[1]
ptr = p[1]
while ptr.pointer:
ptr = ptr.pointer
ptr.pointer = p[2]
else:
p[0] = p[1]
def p_direct_declarator(p):
'''direct_declarator : IDENTIFIER
| TYPE_NAME
| '(' declarator ')'
| direct_declarator '[' constant_expression ']'
| direct_declarator '[' ']'
| direct_declarator '(' parameter_type_list ')'
| direct_declarator '(' identifier_list ')'
| direct_declarator '(' ')'
'''
# TYPE_NAME path is because some types are predefined in wrapper scripts;
# it is not valid C.
if isinstance(p[1], Declarator):
p[0] = p[1]
if p[2] == '[':
a = Array()
a.array = p[0].array
p[0].array = a
if p[3] != ']':
a.size = p[3]
else:
if p[3] == ')':
p[0].parameters = ()
else:
p[0].parameters = p[3]
elif p[1] == '(':
p[0] = p[2]
else:
p[0] = Declarator()
p[0].identifier = p[1]
# Check parameters for (void) and simplify to empty tuple.
if p[0].parameters and len(p[0].parameters) == 1:
param = p[0].parameters[0]
if param.type.specifiers == ['void'] and not param.declarator:
p[0].parameters = ()
def p_pointer(p):
'''pointer : '*'
| '*' type_qualifier_list
| '*' pointer
| '*' type_qualifier_list pointer
'''
if len(p) == 2:
p[0] = Pointer()
elif len(p) == 3:
if type(p[2]) == Pointer:
p[0] = Pointer()
p[0].pointer = p[2]
else:
p[0] = Pointer()
p[0].qualifiers = p[2]
else:
p[0] = Pointer()
p[0].qualifiers = p[2]
p[0].pointer = p[3]
def p_type_qualifier_list(p):
'''type_qualifier_list : type_qualifier
| type_qualifier_list type_qualifier
'''
if len(p) > 2:
p[0] = p[1] + (p[2],)
else:
p[0] = (p[1],)
def p_parameter_type_list(p):
'''parameter_type_list : parameter_list
| parameter_list ',' ELLIPSIS
'''
if len(p) > 2:
p[0] = p[1] + (p[3],)
else:
p[0] = p[1]
def p_parameter_list(p):
'''parameter_list : parameter_declaration
| parameter_list ',' parameter_declaration
'''
if len(p) > 2:
p[0] = p[1] + (p[3],)
else:
p[0] = (p[1],)
def p_parameter_declaration(p):
'''parameter_declaration : declaration_specifiers declarator
| declaration_specifiers abstract_declarator
| declaration_specifiers
'''
p[0] = Parameter()
apply_specifiers(p[1], p[0])
if len(p) > 2:
p[0].declarator = p[2]
def p_identifier_list(p):
'''identifier_list : IDENTIFIER
| identifier_list ',' IDENTIFIER
'''
param = Parameter()
param.declarator = Declarator()
if len(p) > 2:
param.declarator.identifier = p[3]
p[0] = p[1] + (param,)
else:
param.declarator.identifier = p[1]
p[0] = (param,)
def p_type_name(p):
'''type_name : specifier_qualifier_list
| specifier_qualifier_list abstract_declarator
'''
def p_abstract_declarator(p):
'''abstract_declarator : pointer
| direct_abstract_declarator
| pointer direct_abstract_declarator
'''
if len(p) == 2:
p[0] = p[1]
if type(p[0]) == Pointer:
ptr = p[0]
while ptr.pointer:
ptr = ptr.pointer
# Only if doesn't already terminate in a declarator
if type(ptr) == Pointer:
ptr.pointer = Declarator()
else:
p[0] = p[1]
ptr = p[0]
while ptr.pointer:
ptr = ptr.pointer
ptr.pointer = p[2]
def p_direct_abstract_declarator(p):
'''direct_abstract_declarator : '(' abstract_declarator ')'
| '[' ']'
| '[' constant_expression ']'
| direct_abstract_declarator '[' ']'
| direct_abstract_declarator '[' constant_expression ']'
| '(' ')'
| '(' parameter_type_list ')'
| direct_abstract_declarator '(' ')'
| direct_abstract_declarator '(' parameter_type_list ')'
'''
if p[1] == '(' and isinstance(p[2], Declarator):
p[0] = p[2]
else:
if isinstance(p[1], Declarator):
p[0] = p[1]
if p[2] == '[':
a = Array()
a.array = p[0].array
p[0].array = a
if p[3] != ']':
p[0].array.size = p[3]
elif p[2] == '(':
if p[3] == ')':
p[0].parameters = ()
else:
p[0].parameters = p[3]
else:
p[0] = Declarator()
if p[1] == '[':
p[0].array = Array()
if p[2] != ']':
p[0].array.size = p[2]
elif p[1] == '(':
if p[2] == ')':
p[0].parameters = ()
else:
p[0].parameters = p[2]
def p_initializer(p):
'''initializer : assignment_expression
| '{' initializer_list '}'
| '{' initializer_list ',' '}'
'''
def p_initializer_list(p):
'''initializer_list : initializer
| initializer_list ',' initializer
'''
def p_statement(p):
'''statement : labeled_statement
| compound_statement
| expression_statement
| selection_statement
| iteration_statement
| jump_statement
'''
def p_labeled_statement(p):
'''labeled_statement : IDENTIFIER ':' statement
| CASE constant_expression ':' statement
| DEFAULT ':' statement
'''
def p_compound_statement(p):
'''compound_statement : '{' '}'
| '{' statement_list '}'
| '{' declaration_list '}'
| '{' declaration_list statement_list '}'
'''
def p_compound_statement_error(p):
'''compound_statement : '{' error '}'
'''
# Error resynchronisation catch-all
def p_declaration_list(p):
'''declaration_list : declaration
| declaration_list declaration
'''
def p_statement_list(p):
'''statement_list : statement
| statement_list statement
'''
def p_expression_statement(p):
'''expression_statement : ';'
| expression ';'
'''
def p_expression_statement_error(p):
'''expression_statement : error ';'
'''
# Error resynchronisation catch-all
def p_selection_statement(p):
'''selection_statement : IF '(' expression ')' statement
| IF '(' expression ')' statement ELSE statement
| SWITCH '(' expression ')' statement
'''
def p_iteration_statement(p):
'''iteration_statement : WHILE '(' expression ')' statement
| DO statement WHILE '(' expression ')' ';'
| FOR '(' expression_statement expression_statement ')' statement
| FOR '(' expression_statement expression_statement expression ')' statement
'''
def p_jump_statement(p):
'''jump_statement : GOTO IDENTIFIER ';'
| CONTINUE ';'
| BREAK ';'
| RETURN ';'
| RETURN expression ';'
'''
def p_external_declaration(p):
'''external_declaration : declaration
| function_definition
'''
# Intentionally empty
def p_function_definition(p):
'''function_definition : declaration_specifiers declarator declaration_list compound_statement
| declaration_specifiers declarator compound_statement
| declarator declaration_list compound_statement
| declarator compound_statement
'''
def p_error(t):
if not t:
# Crap, no way to get to CParser instance. FIXME TODO
print >> sys.stderr, 'Syntax error at end of file.'
else:
t.lexer.cparser.handle_error('Syntax error at %r' % t.value,
t.filename, t.lineno)
# Don't alter lexer: default behaviour is to pass error production
# up until it hits the catch-all at declaration, at which point
# parsing continues (synchronisation).
# --------------------------------------------------------------------------
# Lexer
# --------------------------------------------------------------------------
class CLexer(object):
def __init__(self, cparser):
self.cparser = cparser
self.type_names = set()
def input(self, tokens):
self.tokens = tokens
self.pos = 0
def token(self):
while self.pos < len(self.tokens):
t = self.tokens[self.pos]
self.pos += 1
if not t:
break
# PP events
if t.type == 'PP_DEFINE':
name, value = t.value
self.cparser.handle_define(
name, value, t.filename, t.lineno)
continue
elif t.type == 'PP_DEFINE_CONSTANT':
name, value = t.value
self.cparser.handle_define_constant(
name, value, t.filename, t.lineno)
continue
elif t.type == 'PP_IFNDEF':
self.cparser.handle_ifndef(t.value, t.filename, t.lineno)
continue
# TODO: other PP tokens
# Transform PP tokens into C tokens
if t.type == 'LPAREN':
t.type = '('
elif t.type == 'PP_NUMBER':
t.type = 'CONSTANT'
elif t.type == 'IDENTIFIER' and t.value in keywords:
t.type = t.value.upper()
elif t.type == 'IDENTIFIER' and t.value in self.type_names:
t.type = 'TYPE_NAME'
t.lexer = self
return t
return None
# --------------------------------------------------------------------------
# Parser
# --------------------------------------------------------------------------
class CPreprocessorParser(preprocessor.PreprocessorParser):
def __init__(self, cparser, **kwargs):
self.cparser = cparser
preprocessor.PreprocessorParser.__init__(self, **kwargs)
def push_file(self, filename, data=None):
if not self.cparser.handle_include(filename):
return
tokens = self.cparser.get_cached_tokens(filename)
if tokens is not None:
self.output += tokens
return
if not data:
data = open(filename).read()
self.lexer.push_input(data, filename)
class CParser(object):
'''Parse a C source file.
Subclass and override the handle_* methods. Call `parse` with a string
to parse.
'''
def __init__(self, stddef_types=True, gnu_types=True, cache_headers=True):
self.preprocessor_parser = CPreprocessorParser(self)
self.parser = yacc.Parser()
yacc.yacc(method='LALR').init_parser(self.parser)
self.parser.cparser = self
self.lexer = CLexer(self)
if stddef_types:
self.lexer.type_names.add('wchar_t')
self.lexer.type_names.add('ptrdiff_t')
self.lexer.type_names.add('size_t')
if gnu_types:
self.lexer.type_names.add('__builtin_va_list')
if sys.platform == 'win32':
self.lexer.type_names.add('__int64')
self.header_cache = {}
self.cache_headers = cache_headers
self.load_header_cache()
def parse(self, filename, data=None, debug=False):
'''Parse a file. Give filename or filename + data.
If `debug` is True, parsing state is dumped to stdout.
'''
if not data:
data = open(filename, 'r').read()
self.handle_status('Preprocessing %s' % filename)
self.preprocessor_parser.parse(filename, data, debug=debug)
self.lexer.input(self.preprocessor_parser.output)
self.handle_status('Parsing %s' % filename)
self.parser.parse(lexer=self.lexer, debug=debug)
def load_header_cache(self, filename=None):
if not filename:
filename = '.header.cache'
try:
self.header_cache = cPickle.load(open(filename, 'rb'))
self.handle_status('Loaded header cache "%s". Found:' % filename)
for header in self.header_cache.keys():
self.handle_status(' %s' % header)
except:
self.handle_status('Failed to load header cache "%s"' % filename)
def save_header_cache(self, filename=None):
if not filename:
filename = '.header.cache'
try:
cPickle.dump(self.header_cache, open(filename, 'wb'))
self.handle_status('Updated header cache "%s"' % filename)
except:
self.handle_status('Failed to update header cache "%s"' % filename)
def get_cached_tokens(self, header):
'''Return a list of tokens for `header`.
If there is no cached copy, return None.
'''
try:
now = os.stat(header).st_mtime
except OSError:
now = time.time()
current_memento = self.preprocessor_parser.get_memento()
if header in self.header_cache:
timestamp, memento, tokens, namespace = self.header_cache[header]
if self.preprocessor_parser.system_headers:
self.handle_status('Not using cached header "%s" because ' \
'of overridden system_headers.' % header)
elif now < timestamp:
self.handle_status('Not using cached header "%s" because ' \
'cached copy is stale.' % header)
elif memento != current_memento:
self.handle_status('Not using cached header "%s" because ' \
'memento differs.' % header)
else:
self.handle_status('Using cached header "%s"' % header)
self.preprocessor_parser.namespace = namespace
return tokens
if self.cache_headers and not self.preprocessor_parser.system_headers:
self.handle_status('Caching header "%s"' % header)
self.cache_headers = False
ppp = preprocessor.PreprocessorParser()
ppp.include_path = self.preprocessor_parser.include_path
ppp.parse(filename=header,
namespace=self.preprocessor_parser.namespace)
self.header_cache[header] = (now, current_memento,
ppp.output, ppp.namespace.copy())
self.save_header_cache()
self.cache_headers = True
return ppp.output
return None
# ----------------------------------------------------------------------
# Parser interface. Override these methods in your subclass.
# ----------------------------------------------------------------------
def handle_error(self, message, filename, lineno):
'''A parse error occured.
The default implementation prints `lineno` and `message` to stderr.
The parser will try to recover from errors by synchronising at the
next semicolon.
'''
print >> sys.stderr, '%s:%s %s' % (filename, lineno, message)
def handle_status(self, message):
'''Progress information.
The default implementationg prints message to stderr.
'''
print >> sys.stderr, message
def handle_include(self, header):
'''#include `header`
Return True to proceed with including the header, otherwise return
False to skip it. The default implementation returns True.
'''
return True
def handle_define(self, name, value, filename, lineno):
'''#define `name` `value`
both are strings, value could not be parsed as an expression
'''
def handle_define_constant(self, name, value, filename, lineno):
'''#define `name` `value`
value is an int or float
'''
def handle_undef(self, name):
'''#undef `name`'''
def handle_if(self, expr):
'''#if `expr`'''
def handle_ifdef(self, name):
'''#ifdef `name`'''
def handle_ifndef(self, name, filename, lineno):
'''#ifndef `name`'''
def handle_elif(self, expr):
'''#elif `expr`'''
def handle_else(self):
'''#else'''
def handle_endif(self):
'''#endif'''
def impl_handle_declaration(self, declaration, filename, lineno):
'''Internal method that calls `handle_declaration`. This method
also adds any new type definitions to the lexer's list of valid type
names, which affects the parsing of subsequent declarations.
'''
if declaration.storage == 'typedef':
declarator = declaration.declarator
if not declarator:
# XXX TEMPORARY while struct etc not filled
return
while declarator.pointer:
declarator = declarator.pointer
self.lexer.type_names.add(declarator.identifier)
self.handle_declaration(declaration, filename, lineno)
def handle_declaration(self, declaration, filename, lineno):
'''A declaration was encountered.
`declaration` is an instance of Declaration. Where a declaration has
multiple initialisers, each is returned as a separate declaration.
'''
pass
class DebugCParser(CParser):
'''A convenience class that prints each invocation of a handle_* method to
stdout.
'''
def handle_include(self, header):
print '#include header=%r' % header
return True
def handle_define(self, name, value, filename, lineno):
print '#define name=%r, value=%r' % (name, value)
def handle_define_constant(self, name, value, filename, lineno):
print '#define constant name=%r, value=%r' % (name, value)
def handle_undef(self, name):
print '#undef name=%r' % name
def handle_if(self, expr):
print '#if expr=%s' % expr
def handle_ifdef(self, name):
print '#ifdef name=%r' % name
def handle_ifndef(self, name, filename, lineno):
print '#ifndef name=%r' % name
def handle_elif(self, expr):
print '#elif expr=%s' % expr
def handle_else(self):
print '#else'
def handle_endif(self):
print '#endif'
def handle_declaration(self, declaration, filename, lineno):
print declaration
if __name__ == '__main__':
DebugCParser().parse(sys.argv[1], debug=True)
| Python |
#!/usr/bin/env python
'''Generate files in pyglet.gl and pyglet/GLU
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import marshal
import optparse
import os.path
import urllib2
import sys
import textwrap
from wraptypes.wrap import CtypesWrapper
script_dir = os.path.abspath(os.path.dirname(__file__))
GLEXT_ABI_H = 'http://www.opengl.org/registry/api/glext.h'
GLEXT_NV_H = 'http://developer.download.nvidia.com/opengl/includes/glext.h'
GLXEXT_ABI_H = 'http://www.opengl.org/registry/api/glxext.h'
GLXEXT_NV_H = 'http://developer.download.nvidia.com/opengl/includes/glxext.h'
WGLEXT_ABI_H = 'http://www.opengl.org/registry/api/wglext.h'
WGLEXT_NV_H = 'http://developer.download.nvidia.com/opengl/includes/wglext.h'
AGL_H = '/System/Library/Frameworks/AGL.framework/Headers/agl.h'
GL_H = '/usr/include/GL/gl.h'
GLU_H = '/usr/include/GL/glu.h'
GLX_H = '/usr/include/GL/glx.h'
WGL_H = os.path.join(script_dir, 'wgl.h')
CACHE_FILE = os.path.join(script_dir, '.gengl.cache')
_cache = {}
def load_cache():
global _cache
if os.path.exists(CACHE_FILE):
try:
_cache = marshal.load(open(CACHE_FILE, 'rb')) or {}
except:
pass
_cache = {}
def save_cache():
try:
marshal.dump(_cache, open(CACHE_FILE, 'wb'))
except:
pass
def read_url(url):
if url in _cache:
return _cache[url]
if os.path.exists(url):
data = open(url).read()
else:
data = urllib2.urlopen(url).read()
_cache[url] = data
save_cache()
return data
class GLWrapper(CtypesWrapper):
requires = None
requires_prefix = None
def __init__(self, header):
self.header = header
super(GLWrapper, self).__init__()
def print_preamble(self):
import time
print >> self.file, textwrap.dedent("""
# This content is generated by %(script)s.
# Wrapper for %(header)s
""" % {
'header': self.header,
'date': time.ctime(),
'script': __file__,
}).lstrip()
def handle_ctypes_function(self, name, restype, argtypes, filename, lineno):
if self.does_emit(name, filename):
self.emit_type(restype)
for a in argtypes:
self.emit_type(a)
self.all_names.append(name)
print >> self.file, '# %s:%d' % (filename, lineno)
print >> self.file, '%s = _link_function(%r, %s, [%s], %r)' % \
(name, name, str(restype),
', '.join([str(a) for a in argtypes]), self.requires)
print >> self.file
def handle_ifndef(self, name, filename, lineno):
if self.requires_prefix and \
name[:len(self.requires_prefix)] == self.requires_prefix:
self.requires = name[len(self.requires_prefix):]
print >> self.file, '# %s (%s:%d)' % \
(self.requires, filename, lineno)
def progress(msg):
print >> sys.stderr, msg
marker_begin = '# BEGIN GENERATED CONTENT (do not edit below this line)\n'
marker_end = '# END GENERATED CONTENT (do not edit above this line)\n'
class ModuleWrapper(object):
def __init__(self, header, filename,
prologue='', requires_prefix=None, system_header=None,
link_modules=()):
self.header = header
self.filename = filename
self.prologue = prologue
self.requires_prefix = requires_prefix
self.system_header = system_header
self.link_modules = link_modules
def wrap(self, dir):
progress('Updating %s...' % self.filename)
source = read_url(self.header)
filename = os.path.join(dir, self.filename)
prologue = []
epilogue = []
state = 'prologue'
try:
for line in open(filename):
if state == 'prologue':
prologue.append(line)
if line == marker_begin:
state = 'generated'
elif state == 'generated':
if line == marker_end:
state = 'epilogue'
epilogue.append(line)
elif state == 'epilogue':
epilogue.append(line)
except IOError:
prologue = [marker_begin]
epilogue = [marker_end]
state = 'epilogue'
if state != 'epilogue':
raise Exception('File exists, but generated markers are corrupt '
'or missing')
outfile = open(filename, 'w')
print >> outfile, ''.join(prologue)
wrapper = GLWrapper(self.header)
if self.system_header:
wrapper.preprocessor_parser.system_headers[self.system_header] = \
source
header_name = self.system_header or self.header
wrapper.begin_output(outfile,
library=None,
link_modules=self.link_modules,
emit_filenames=(header_name,))
wrapper.requires_prefix = self.requires_prefix
source = self.prologue + source
wrapper.wrap(header_name, source)
wrapper.end_output()
print >> outfile, ''.join(epilogue)
modules = {
'gl':
ModuleWrapper(GL_H, 'gl.py'),
'glu':
ModuleWrapper(GLU_H, 'glu.py'),
'glext_arb':
ModuleWrapper(GLEXT_ABI_H, 'glext_arb.py',
requires_prefix='GL_', system_header='GL/glext.h',
prologue='#define GL_GLEXT_PROTOTYPES\n#include <GL/gl.h>\n'),
'glext_nv':
ModuleWrapper(GLEXT_NV_H, 'glext_nv.py',
requires_prefix='GL_', system_header='GL/glext.h',
prologue='#define GL_GLEXT_PROTOTYPES\n#include <GL/gl.h>\n'),
'glx':
ModuleWrapper(GLX_H, 'glx.py',
requires_prefix='GLX_',
link_modules=('pyglet.libs.x11.xlib',)),
'glxext_arb':
ModuleWrapper(GLXEXT_ABI_H, 'glxext_arb.py', requires_prefix='GLX_',
system_header='GL/glxext.h',
prologue='#define GLX_GLXEXT_PROTOTYPES\n#include <GL/glx.h>\n',
link_modules=('pyglet.libs.x11.xlib', 'pyglet.gl.glx')),
'glxext_nv':
ModuleWrapper(GLXEXT_NV_H, 'glxext_nv.py', requires_prefix='GLX_',
system_header='GL/glxext.h',
prologue='#define GLX_GLXEXT_PROTOTYPES\n#include <GL/glx.h>\n',
link_modules=('pyglet.libs.x11.xlib', 'pyglet.gl.glx')),
'agl':
ModuleWrapper(AGL_H, 'agl.py'),
'wgl':
ModuleWrapper(WGL_H, 'wgl.py'),
'wglext_arb':
ModuleWrapper(WGLEXT_ABI_H, 'wglext_arb.py', requires_prefix='WGL_',
prologue='#define WGL_WGLEXT_PROTOTYPES\n'\
'#include "%s"\n' % WGL_H.encode('string_escape')),
'wglext_nv':
ModuleWrapper(WGLEXT_NV_H, 'wglext_nv.py', requires_prefix='WGL_',
prologue='#define WGL_WGLEXT_PROTOTYPES\n'\
'#include "%s"\n' % WGL_H.encode('string_escape')),
}
if __name__ == '__main__':
op = optparse.OptionParser()
op.add_option('-D', '--dir', dest='dir',
help='output directory')
op.add_option('-r', '--refresh-cache', dest='refresh_cache',
help='clear cache first', action='store_true')
options, args = op.parse_args()
if not options.refresh_cache:
load_cache()
else:
save_cache()
if not args:
print >> sys.stderr, 'Specify module(s) to generate:'
print >> sys.stderr, ' %s' % ' '.join(modules.keys())
if not options.dir:
options.dir = os.path.join(script_dir, os.path.pardir, 'pyglet', 'gl')
if not os.path.exists(options.dir):
os.makedirs(options.dir)
for arg in args:
if arg not in modules:
print >> sys.stderr, "Don't know how to make '%s'" % arg
continue
modules[arg].wrap(options.dir)
| Python |
#!/usr/bin/env python
'''Simple viewer for DDS texture files.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from ctypes import *
import getopt
import sys
import textwrap
from SDL import *
from pyglet.gl.VERSION_1_1 import *
import pyglet.dds
import pyglet.event
import pyglet.image
import pyglet.sprite
import pyglet.window
from OpenGL.GLU import *
def usage():
print textwrap.dedent('''
Usage: ddsview.py [--header] texture1.dds texture2.dds ...
--header Dump the header of each file instead of displaying.
Within the program, press:
left/right keys Flip between loaded textures
up/down keys Increase/decrease mipmap level for a texture
space Toggle flat or sphere view
Click and drag with mouse to reposition texture with wrapping.
''')
texture_index = 0
textures = []
mipmap_level = 0
last_pos = None
texture_offset = [0, 0]
view = 'flat'
sphere_angle = 0
def keydown(character, symbol, modifiers):
global mipmap_level, texture_index
if symbol == SDLK_DOWN:
mipmap_level = max(0, mipmap_level - 1)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, mipmap_level)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipmap_level)
elif symbol == SDLK_UP:
mipmap_level = mipmap_level + 1
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, mipmap_level)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipmap_level)
elif symbol == SDLK_LEFT:
texture_index = max(0, texture_index - 1)
elif symbol == SDLK_RIGHT:
texture_index = min(len(textures) - 1, texture_index + 1)
elif symbol == SDLK_SPACE:
toggle_view()
return True
def mousemotion(x, y):
global last_pos
state, x, y = SDL_GetMouseState()
if state & SDL_BUTTON(1):
texture_offset[0] += x - last_pos[0]
texture_offset[1] += y - last_pos[1]
update_texture_matrix()
last_pos = x, y
def update_texture_matrix():
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glTranslatef(-texture_offset[0] / float(textures[texture_index].size[0]),
-texture_offset[1] / float(textures[texture_index].size[1]),
0)
glMatrixMode(GL_MODELVIEW)
def toggle_view():
global view
if view != 'flat':
pyglet.event.pop()
pyglet.window.set_2d()
view = 'flat'
else:
pyglet.event.push()
pyglet.event.on_mousemotion(sphere_mousemotion)
pyglet.window.set_3d()
glEnable(GL_LIGHT0)
glLightfv(GL_LIGHT0, GL_POSITION, (c_float * 4)(0.5, 0.5, 1, 0))
view = 'sphere'
def sphere_mousemotion(x, y):
# TODO: virtual trackball
return True
def draw_sphere():
global sphere_angle
glPushMatrix()
glTranslatef(0., 0., -4)
glRotatef(sphere_angle, 0, 1, 0)
glRotatef(90, 1, 0, 0)
sphere_angle += 0.01
glPushAttrib(GL_ENABLE_BIT)
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHTING)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, textures[texture_index].id)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
sphere = gluNewQuadric()
gluQuadricTexture(sphere, True)
gluSphere(sphere, 1.0, 100, 100)
gluDeleteQuadric(sphere)
glPopAttrib()
glPopMatrix()
def main(args):
header = False
options, args = getopt.getopt(args[1:], 'h', ['help', 'header'])
for option, value in options:
if option in ('-h', '--help'):
usage()
sys.exit()
elif option == '--header':
header = True
if len(args) < 1:
usage()
sys.exit()
if header:
for arg in args:
print pyglet.dds.DDSURFACEDESC2(open(arg,
'r').read(pyglet.dds.DDSURFACEDESC2.get_size()))
else:
pyglet.window.set_window(resizable=True)
global textures, texture_index
textures = [pyglet.dds.load_dds(arg) for arg in args]
texture_index = 0
pyglet.window.resize(*textures[0].size)
pyglet.event.push()
pyglet.event.on_keydown(keydown)
pyglet.event.on_mousemotion(mousemotion)
global last_pos
state, x, y = SDL_GetMouseState()
last_pos = x, y
glClearColor(0, 0, 0, 0)
while not pyglet.event.is_quit():
pyglet.event.pump()
pyglet.window.clear()
if view == 'flat':
textures[texture_index].draw()
elif view == 'sphere':
draw_sphere()
pyglet.window.flip()
if __name__ == '__main__':
main(sys.argv)
| Python |
#!/usr/bin/env python
'''Print OpenAL driver information.
Options:
-d <device> Optionally specify device to query.
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import ctypes
import optparse
import sys
from pyglet.media.drivers import openal
from pyglet.media.drivers.openal import al
from pyglet.media.drivers.openal import alc
def split_nul_strings(s):
# NUL-separated list of strings, double-NUL-terminated.
nul = False
i = 0
while True:
if s[i] == '\0':
if nul:
break
else:
nul = True
else:
nul = False
i += 1
s = s[:i - 1]
return s.split('\0')
if __name__ == '__main__':
op = optparse.OptionParser()
op.add_option('-d', '--device', dest='device',
help='use device DEVICE', metavar='DEVICE')
(options, args) = op.parse_args(sys.argv[1:])
default_device = ctypes.cast(
alc.alcGetString(None, alc.ALC_DEFAULT_DEVICE_SPECIFIER),
ctypes.c_char_p).value
capture_default_device = ctypes.cast(
alc.alcGetString(None, alc.ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
ctypes.c_char_p).value
print 'Default device: %s' % default_device
print 'Default capture device: %s' % capture_default_device
if alc.alcIsExtensionPresent(None, 'ALC_ENUMERATION_EXT'):
# Hmm, actually not allowed to pass NULL to alcIsExtension present..
# how is this supposed to work?
devices = split_nul_strings(
alc.alcGetString(None, alc.ALC_DEVICE_SPECIFIER))
capture_devices = split_nul_strings(
alc.alcGetString(None, alc.ALC_CAPTURE_DEVICE_SPECIFIER))
print 'Devices: %s' % ', '.join(devices)
print 'Capture devices: %s' % ', '.join(capture_devices)
print
if options.device:
print 'Using device "%s"...' % options.device
driver = openal.create_audio_driver(options.device)
else:
print 'Using default device...'
driver = openal.create_audio_driver()
print 'OpenAL version %d.%d' % driver.get_version()
print 'Extensions: %s' % ', '.join(driver.get_extensions())
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
from wraptypes.wrap import main as wrap
import os.path
import sys
import pyglet
pyglet.options['shadow_window'] = False
if __name__ == '__main__':
if not os.path.exists('pyglet/window'):
assert False, 'Run with CWD = trunk root.'
names = sys.argv[1:]
if pyglet.compat_platform.startswith('linux'):
if 'xlib' in names:
wrap('tools/wraptypes/wrap.py',
'-opyglet/libs/x11/xlib.py',
'-lX11',
'/usr/include/X11/Xlib.h',
'/usr/include/X11/X.h',
'/usr/include/X11/Xutil.h')
if 'xinerama' in names:
wrap('tools/wraptypes/wrap.py',
'-opyglet/libs/x11/xinerama.py',
'-lXinerama',
'-mpyglet.libs.x11.xlib',
'/usr/include/X11/extensions/Xinerama.h')
if 'xsync' in names:
print '------------------------------------'
print 'WARNING xsync requires import hacks.'
print ' ... copy over from current xsync.py'
print '------------------------------------'
wrap('tools/wraptypes/wrap.py',
'-opyglet/libs/x11/xsync.py',
'-lXext',
'-mpyglet.libs.x11.xlib',
'-i/usr/include/X11/Xlib.h',
'-i/usr/include/X11/X.h',
'-i/usr/include/X11/Xdefs.h',
'-DStatus=int',
'/usr/include/X11/extensions/sync.h')
if 'xinput' in names:
wrap('tools/wraptypes/wrap.py',
'-opyglet/libs/x11/xinput.py',
'-lXi',
'-mpyglet.libs.x11.xlib',
'-i/usr/include/X11/Xlib.h',
'-i/usr/include/X11/X.h',
'-i/usr/include/X11/Xdefs.h',
'/usr/include/X11/extensions/XInput.h',
'/usr/include/X11/extensions/XI.h')
if 'xrandr' in names:
wrap('tools/wraptypes/wrap.py',
'-oexperimental/modeswitch/lib_xrandr.py',
'-lXrandr',
'-mpyglet.libs.x11.xlib',
'-i/usr/include/X11/Xlib.h',
'-i/usr/include/X11/X.h',
'-i/usr/include/X11/Xdefs.h',
'/usr/include/X11/extensions/Xrandr.h',
'/usr/include/X11/extensions/randr.h')
if 'xf86vmode' in names:
wrap('tools/wraptypes/wrap.py',
'-opyglet/libs/x11/xf86vmode.py',
'-lXxf86vm',
'-mpyglet.libs.x11.xlib',
'-i/usr/include/X11/Xlib.h',
'-i/usr/include/X11/X.h',
'-i/usr/include/X11/Xdefs.h',
'/usr/include/X11/extensions/xf86vmode.h')
if 'pulseaudio' in names:
wrap('tools/wraptypes/wrap.py',
'-opyglet/media/drivers/pulse/lib_pulseaudio.py',
'-lpulse',
'-i/usr/include/pulse/pulseaudio.h',
'/usr/include/pulse/mainloop-api.h',
'/usr/include/pulse/sample.h',
'/usr/include/pulse/def.h',
'/usr/include/pulse/context.h',
'/usr/include/pulse/stream.h',
'/usr/include/pulse/introspect.h',
'/usr/include/pulse/subscribe.h',
'/usr/include/pulse/scache.h',
'/usr/include/pulse/version.h',
'/usr/include/pulse/error.h',
'/usr/include/pulse/operation.h',
'/usr/include/pulse/channelmap.h',
'/usr/include/pulse/volume.h',
'/usr/include/pulse/xmalloc.h',
'/usr/include/pulse/utf8.h',
'/usr/include/pulse/thread-mainloop.h',
'/usr/include/pulse/mainloop.h',
'/usr/include/pulse/mainloop-signal.h',
'/usr/include/pulse/util.h',
'/usr/include/pulse/timeval.h')
| Python |
#!/usr/bin/env python
'''
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import getopt
import os.path
import sys
import textwrap
import pyglet.dds
import pyglet.image
import pyglet.window
def usage():
print textwrap.dedent('''
convert.py <input-file> <output-file>
''')
def main(args):
del args[0]
pyglet.window.set_window() # need a window for OpenGL context
if len(args) < 2:
usage()
sys.exit()
srcimage = args[0]
srctype = os.path.splitext(srcimage)[1].lower()
destimage = args[1]
desttype = os.path.splitext(destimage)[1].lower()
if srctype == '.dds':
texture = pyglet.dds.load_dds(srcimage)
else:
texture = pyglet.image.Texture.from_surface(pyglet.image.load(srcimage))
print texture.size
if desttype == '.dds':
raise NotImplementedError, 'TODO: save compressed texture'
else:
pyglet.image.save(texture, destimage)
if __name__ == '__main__':
main(sys.argv)
| Python |
'''Usage: %s <arguments>
-h h draw hexes with given height in a rectangular grid
-x h draw hexes with given height in a hex grid
-r w[,h] draw a rect grid
-s w,h map size in cells (default=5,5)
-f render flat (default)
-o render orthographic projection
-a sx,sy,sz render axiometric projection (scaled in x, y, z)
-h this help
Samples:
-h32 -p2
draw hexes in a rect grid, cell height 32
-x32 -s5,15
draw a hex grid, cell height 32
-x32
draw a rect grid, width and height 32
-r16,32 -s10,10
draw a 10x10 rect grid, width and height 32
Press "s" to save the grid off a file.
'''
import sys, getopt, os
import pyglet.ext.scene2d
import pyglet.window
import pyglet.window.event
from pyglet import clock
import pyglet.image
from pyglet.ext.scene2d.debug import gen_hex_map, gen_rect_map, gen_recthex_map
try:
optlist, args = getopt.getopt(sys.argv[1:], 'x:r:s:foa:p:h:')
except getopt.GetoptError, error:
print error
print __doc__%sys.argv[0]
sys.exit()
size = (5, 5)
renderer = pyglet.ext.scene2d.FlatView
maptype = None
filename = { 'r': 'flat', 'e': '5x5' }
for opt, value in optlist:
if opt == '-h':
maptype = 'recthex'
ch = int(value)
filename['x'] = 'recthex(%d)'%ch
elif opt == '-x':
maptype = 'hex'
ch = int(value)
filename['x'] = 'hex(%d)'%ch
elif opt == '-r':
maptype = 'rect'
args = map(int, value.split(','))
if len(args) == 1:
args *= 2
cw, ch = args
filename['x'] = 'rect(%dx%d)'%tuple(args)
elif opt == '-s':
size = map(int, value.split(','))
filename['e'] = '%dx%d'%tuple(size)
elif opt == '-f':
renderer = pyglet.ext.scene2d.FlatView
filename['r'] = 'flat'
elif opt == '-o':
renderer = pyglet.ext.scene2d.AxiometricView
scale = (1, 1, 1)
filename['r'] = 'iso'
elif opt == '-a':
renderer = pyglet.ext.scene2d.AxiometricView
scale = map(float, value.split(','))
filename['r'] = 'axio(%g,%g,%g)'%scale
if maptype is None:
print 'ERROR: -x or -r required'
print __doc__%sys.argv[0]
sys.exit()
filename = '%(x)s-%(e)s-%(r)s'%filename
w = pyglet.window.Window(width=1, height=1, visible=False, alpha_size=8)
mw, mh = size
if maptype == 'recthex':
m = gen_recthex_map([[{}]*mh]*mw, ch)
elif maptype == 'hex':
m = gen_hex_map([[{}]*mh]*mw, ch)
else:
m = gen_rect_map([[{}]*mh]*mw, cw, ch)
pxw = m.pxw
pxh = m.pxh
w.set_size(width=pxw, height=pxh)
w.set_visible()
r = pyglet.ext.scene2d.FlatView(0, 0, pxw, pxh, layers=[m])
class SaveHandler:
def on_text(self, text):
if text != 's': return pyglet.window.event.EVENT_UNHANDLED
image = pyglet.image.BufferImage().get_raw_image()
fn = filename + '.png'
n = 1
while os.path.exists(fn):
fn = filename + str(n) + '.png'
n += 1
print "Saving to '%s'"%fn
image.save(fn)
w.push_handlers(SaveHandler())
clock.set_fps_limit(10)
while not w.has_exit:
clock.tick()
w.dispatch_events()
r.clear((0,0,0,0))
r.draw()
w.flip()
| Python |
# 2. Create build/pyglet.wxs from pyglet.wxs, add all file components
# 3. Run candle and light on build/pyglet.wxs to generate
# ../../dist/pyglet.msi
import os
import re
import shutil
import subprocess
from uuid import uuid1
from xml.dom.minidom import parse
import pkg_resources
class PythonVersion(object):
def __init__(self, version, key_root, display_version):
self.version = version
self.display_version = display_version
self.id = 'PY' + version.replace('.', '') + key_root
self.key_root = key_root
self.key = r'SOFTWARE\Python\PythonCore\%s\InstallPath' % version
self.dir_prop = 'PYTHONHOME%s' % self.id
self.exe_prop = 'PYTHONEXE%s' % self.id
self.components = []
PYTHON_VERSIONS = (
PythonVersion('2.4', 'HKLM', 'Python 2.4'),
PythonVersion('2.5', 'HKLM', 'Python 2.5'),
PythonVersion('2.6', 'HKLM', 'Python 2.6'),
PythonVersion('2.4', 'HKCU', 'Python 2.4 (current user only)'),
PythonVersion('2.5', 'HKCU', 'Python 2.5 (current user only)'),
PythonVersion('2.6', 'HKCU', 'Python 2.6 (current user only)'),
)
MISSING_PYTHON_MESSAGE = 'pyglet requires Python 2.4 or later. The ' \
'installation will be aborted.'
exclude_packages = []
ids = set()
def id(name):
num = 1
id = name
while id in ids:
num += 1
id = '%s%d' % (name, num)
ids.add(id)
return id
shortnames = set()
def shortname(name, ext):
num = 1
shortname = '%s.%s' % (name[:8], ext)
while shortname in shortnames:
num += 1
shortname = '%s%02d.%s' % (name[:6], num, ext)
shortnames.add(shortname)
return shortname
def node(doc, node_name, **kwargs):
node = doc.createElement(node_name)
for key, value in kwargs.items():
node.setAttribute(key, value)
return node
def add_package(name, src_dir, doc, dest_node, pyver):
if name in exclude_packages:
return
src_path = os.path.join(src_dir, name)
directory = node(doc, 'Directory',
Id=id('%sDir' % name),
Name=name)
dest_node.appendChild(doc.createTextNode('\n\n'))
dest_node.appendChild(directory)
dest_node.appendChild(doc.createTextNode('\n\n'))
directory.appendChild(doc.createTextNode('\n'))
for filename in os.listdir(src_path):
file_path = os.path.join(src_path, filename)
if os.path.isdir(file_path):
if os.path.exists(os.path.join(file_path, '__init__.py')):
add_package(filename, src_path, doc, directory, pyver)
elif filename.endswith('.py'):
add_module(filename, src_path, doc, directory, pyver)
def component_id(name, pyver):
component = id(name)
pyver.components.append(component)
return component
guid_seq = 0
def guid():
global guid_seq
guid_seq += 1
return uuid1(clock_seq=guid_seq).hex.upper()
def add_module(name, src_dir, doc, dest_node, pyver):
src_path = os.path.join(src_dir, name)
basefile = os.path.splitext(name)[0]
component = node(doc, 'Component',
Id= component_id('%sComponent' % basefile, pyver),
Guid=guid())
component.appendChild(
node(doc, 'File',
Id=id('%sPy' % basefile),
Name=name,
DiskId='1',
Source=src_path))
component.appendChild(
node(doc, 'RemoveFile',
Id=id('%sPyc' % basefile),
Name='%s.pyc' % basefile,
On='uninstall'))
component.appendChild(
node(doc, 'RemoveFile',
Id=id('%sPyo' % basefile),
Name='%s.pyo' % basefile,
On='uninstall'))
dest_node.appendChild(component)
# Some readability
dest_node.appendChild(doc.createTextNode('\n'))
def call(cmd):
print cmd
return subprocess.call(cmd, shell=True)
if __name__ == '__main__':
script_dir = os.path.dirname(__file__)
root_dir = os.path.join(script_dir, '../..')
dist_dir = os.path.join(root_dir, 'dist')
try:
os.makedirs(dist_dir)
except OSError:
pass
# Copy current avbin into res
shutil.copyfile('c:/windows/system32/avbin.dll',
os.path.join(script_dir, 'res', 'avbin.dll'))
# Determine release version from setup.py
version_re = re.compile("VERSION = '([^']*)'")
for line in open(os.path.join(root_dir, 'setup.py')):
match = version_re.match(line)
if match:
version = match.groups()[0]
# Create a Windows-friendly dotted number for the version
# Version string must not have any letters, so use:
# alpha = x.x.x.(0 + alpha num)
# beta = x.x.x.(16 + beta num)
# rc = x.x.x.(32 + rc num)
# release = x.x.x.128 -->
parts = list(pkg_resources.parse_version(version))
major = int(parts.pop(0))
minor = patch = tagnum = 0
if parts[0][0] != '*':
minor = int(parts.pop(0))
if parts[0][0] != '*':
patch = int(parts.pop(0))
tag = parts.pop(0)
if tag == '*alpha':
base = 0
elif tag == '*beta':
base = 16
elif tag == '*rc':
base = 32
elif tag == '*final':
base = 128
else:
assert False, 'Unrecognised version tag "%s"' % tag
if parts and parts[0][0] != '*':
tagnum = int(parts.pop(0))
assert not parts or parts[0] == '*final'
version_windows = '%d.%d.%d.%d' % (major, minor, patch, base + tagnum)
print 'Version %s is Windows version %s' % (version, version_windows)
print 'Writing pyglet.wxs'
# Open template wxs and find Product element
wxs = parse(os.path.join(script_dir, 'pyglet.in.wxs'))
Product = wxs.getElementsByTagName('Product')[0]
Product.setAttribute('Version', version_windows)
# Add Python discovery
for pyver in PYTHON_VERSIONS:
Property = node(wxs, 'Property',
Id=pyver.dir_prop)
Property.appendChild(
node(wxs, 'RegistrySearch',
Id='%sRegSearch' % pyver.dir_prop,
Root=pyver.key_root,
Key=pyver.key,
Type='directory'))
Product.appendChild(Property)
# Add install conditional on at least one Python version present.
Condition = node(wxs, 'Condition',
Message=MISSING_PYTHON_MESSAGE)
Condition.appendChild(wxs.createTextNode(
' or '.join([pyver.dir_prop for pyver in PYTHON_VERSIONS])))
Product.appendChild(Condition)
# Get TARGETDIR Directory element
for elem in wxs.getElementsByTagName('Directory'):
if elem.getAttribute('Id') == 'TARGETDIR':
target_dir = elem
break
# Create entire set of components for each python version (WiX 3 will
# ensure only one copy of the source file is in the archive)
for pyver in PYTHON_VERSIONS:
python_home = node(wxs, 'Directory',
Id=pyver.dir_prop)
target_dir.appendChild(python_home)
lib_dir = node(wxs, 'Directory',
Id='%sLibDir' % pyver.dir_prop,
Name='Lib')
python_home.appendChild(lib_dir)
site_packages = node(wxs, 'Directory',
Id='%sSitePackages' % pyver.dir_prop,
Name='site-packages')
lib_dir.appendChild(site_packages)
add_package('pyglet', root_dir, wxs, site_packages, pyver)
# Add all components to features
RuntimeFeature = wxs.getElementsByTagName('Feature')[0]
for pyver in PYTHON_VERSIONS:
feature = node(wxs, 'Feature',
Id='RuntimeFeature%s' % pyver.id,
Title='pyglet runtime for %s' % pyver.display_version,
Level='1',
AllowAdvertise='no')
condition = node(wxs, 'Condition',
Level='0')
condition.appendChild(wxs.createTextNode('NOT ' + pyver.dir_prop))
feature.appendChild(condition)
for component in pyver.components:
feature.appendChild(node(wxs, 'ComponentRef',
Id=component))
feature.appendChild(wxs.createTextNode('\n'))
RuntimeFeature.appendChild(feature)
# Add byte compilation custom actions
last_action = 'InstallFinalize'
InstallExecuteSequence = \
wxs.getElementsByTagName('InstallExecuteSequence')[0]
UI = wxs.getElementsByTagName('UI')[0]
for pyver in PYTHON_VERSIONS:
# Actions are conditional on the feature being installed
def cond(node):
node.appendChild(wxs.createTextNode(
'(&RuntimeFeature%s=3) AND NOT(!RuntimeFeature%s=3)' % (
pyver.id, pyver.id)))
return node
# Define the actions
Product.appendChild(node(wxs, 'CustomAction',
Id='SetPythonExe%s' % pyver.id,
Property=pyver.exe_prop,
Value=r'[%s]\pythonw.exe' % pyver.dir_prop))
Product.appendChild(node(wxs, 'CustomAction',
Id='ByteCompile%s' % pyver.id,
Property=pyver.exe_prop,
ExeCommand=r'-c "import compileall; compileall.compile_dir(\"[%s]\Lib\site-packages\pyglet\", force=1)"' % pyver.dir_prop,
Return='ignore'))
Product.appendChild(node(wxs, 'CustomAction',
Id='ByteOptimize%s' % pyver.id,
Property=pyver.exe_prop,
ExeCommand=r'-OO -c "import compileall; compileall.compile_dir(\"[%s]\Lib\site-packages\pyglet\", force=1)"' % pyver.dir_prop,
Return='ignore'))
# Schedule execution of these actions
InstallExecuteSequence.appendChild(cond(
node(wxs, 'Custom',
Action='SetPythonExe%s' % pyver.id,
After=last_action)))
InstallExecuteSequence.appendChild(cond(
node(wxs, 'Custom',
Action='ByteCompile%s' % pyver.id,
After='SetPythonExe%s' % pyver.id)))
InstallExecuteSequence.appendChild(cond(
node(wxs, 'Custom',
Action='ByteOptimize%s' % pyver.id,
After='ByteCompile%s' % pyver.id)))
last_action = 'ByteOptimize%s' % pyver.id
# Set progress text for the actions
progress = node(wxs, 'ProgressText',
Action='ByteCompile%s' % pyver.id)
progress.appendChild(wxs.createTextNode(
'Byte-compiling modules for Python %s' % pyver.version))
UI.appendChild(progress)
progress = node(wxs, 'ProgressText',
Action='ByteOptimize%s' % pyver.id)
progress.appendChild(wxs.createTextNode(
'Byte-optimizing modules for Python %s' % pyver.version))
UI.appendChild(progress)
# Write wxs file
wxs.writexml(open(os.path.join(script_dir, 'pyglet.wxs'), 'w'))
# Compile
call('candle -out %s %s' % (os.path.join(script_dir, 'pyglet.wixobj'),
os.path.join(script_dir, 'pyglet.wxs')))
# Link
call('light -sval -out %s %s' % \
(os.path.join(dist_dir, 'pyglet-%s.msi' % version),
os.path.join(script_dir, 'pyglet.wixobj')))
| Python |
#!/usr/bin/env python
'''Upload dist/ files to code.google.com. For Alex only :-)
'''
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import os
import re
import sys
base = os.path.dirname(__file__)
root = os.path.join(base, '../..')
dist = os.path.join(root, 'dist')
sys.path.insert(0, root)
import pyglet
import googlecode_upload
if __name__ == '__main__':
version = 'pyglet-%s' % pyglet.version
print 'Preparing to upload %s' % version
password = open(os.path.expanduser('~/.googlecode-passwd')).read().strip()
descriptions = {}
for line in open(os.path.join(base, 'descriptions.txt')):
suffix, description = line.split(' ', 1)
descriptions[suffix] = description.strip()
files = {}
version_pattern = re.compile('%s[.-].*' % version)
for filename in os.listdir(dist):
if version_pattern.match(filename):
description = descriptions.get(filename[len(version):])
if not description:
print 'No description for %s' % filename
sys.exit(1)
description = '%s %s' % (pyglet.version, description)
labels = []
if filename.endswith('.tar.gz') or filename.endswith('.zip') and\
'docs' not in filename:
labels.append('Type-Source')
elif filename.endswith('.msi'):
labels.append('OpSys-Windows')
elif filename.endswith('.dmg'):
labels.append('OpSys-OSX')
# Don't feature 1.1 until release time
#if not filename.endswith('.egg'):
# labels.append('Featured')
files[filename] = description, labels
print filename
print ' %s' % description
print ' %s' % ', '.join(labels)
print 'Ok to upload? [type "y"]'
if raw_input().strip() != 'y':
print 'Aborted.'
sys.exit(1)
for filename, (description, labels) in files.items():
status, reason, url = googlecode_upload.upload(
os.path.join(dist, filename),
'pyglet',
'Alex.Holkner',
password,
description,
labels)
if url:
print 'OK: %s' % url
else:
print 'Error: %s (%s)' % (reason, status)
print 'Done!'
| Python |
#!/usr/bin/env python
#
# Copyright 2006 Google Inc. All Rights Reserved.
# Author: danderson@google.com (David Anderson)
#
# Script for uploading files to a Google Code project.
#
# This is intended to be both a useful script for people who want to
# streamline project uploads and a reference implementation for
# uploading files to Google Code projects.
#
# To upload a file to Google Code, you need to provide a path to the
# file on your local machine, a small summary of what the file is, a
# project name, and a valid account that is a member or owner of that
# project. You can optionally provide a list of labels that apply to
# the file. The file will be uploaded under the same name that it has
# in your local filesystem (that is, the "basename" or last path
# component). Run the script with '--help' to get the exact syntax
# and available options.
#
# Note that the upload script requests that you enter your
# googlecode.com password. This is NOT your Gmail account password!
# This is the password you use on googlecode.com for committing to
# Subversion and uploading files. You can find your password by going
# to http://code.google.com/hosting/settings when logged in with your
# Gmail account.
#
# If you are looking at this script as a reference for implementing
# your own Google Code file uploader, then you should take a look at
# the upload() function, which is the meat of the uploader. You
# basically need to build a multipart/form-data POST request with the
# right fields and send it to https://PROJECT.googlecode.com/files .
# Authenticate the request using HTTP Basic authentication, as is
# shown below.
#
# Licensed under the terms of the Apache Software License 2.0:
# http://www.apache.org/licenses/LICENSE-2.0
#
# Questions, comments, feature requests and patches are most welcome.
# Please direct all of these to the Google Code users group:
# http://groups-beta.google.com/group/google-code-hosting
"""Google Code file uploader script.
"""
__author__ = 'danderson@google.com (David Anderson)'
import httplib
import os.path
import optparse
import getpass
import base64
def upload(file, project_name, user_name, password, summary, labels=None):
"""Upload a file to a Google Code project's file server.
Args:
file: The local path to the file.
project_name: The name of your project on Google Code.
user_name: Your Google account name.
password: The googlecode.com password for your account.
Note that this is NOT your global Google Account password!
summary: A small description for the file.
labels: an optional list of label strings with which to tag the file.
Returns: a tuple:
http_status: 201 if the upload succeeded, something else if an
error occured.
http_reason: The human-readable string associated with http_status
file_url: If the upload succeeded, the URL of the file on Google
Code, None otherwise.
"""
# The login is the user part of user@gmail.com. If the login provided
# is in the full user@domain form, strip it down.
if '@' in user_name:
user_name = user_name[:user_name.index('@')]
form_fields = [('summary', summary)]
if labels is not None:
form_fields.extend([('label', l.strip()) for l in labels])
content_type, body = encode_upload_request(form_fields, file)
upload_host = '%s.googlecode.com' % project_name
upload_uri = '/files'
auth_token = base64.b64encode('%s:%s'% (user_name, password))
headers = {
'Authorization': 'Basic %s' % auth_token,
'User-Agent': 'Googlecode.com uploader v0.9.4',
'Content-Type': content_type,
}
server = httplib.HTTPSConnection(upload_host)
server.request('POST', upload_uri, body, headers)
resp = server.getresponse()
server.close()
if resp.status == 201:
location = resp.getheader('Location', None)
else:
location = None
return resp.status, resp.reason, location
def encode_upload_request(fields, file_path):
"""Encode the given fields and file into a multipart form body.
fields is a sequence of (name, value) pairs. file is the path of
the file to upload. The file will be uploaded to Google Code with
the same file name.
Returns: (content_type, body) ready for httplib.HTTP instance
"""
BOUNDARY = '----------Googlecode_boundary_reindeer_flotilla'
CRLF = '\r\n'
body = []
# Add the metadata about the upload first
for key, value in fields:
body.extend(
['--' + BOUNDARY,
'Content-Disposition: form-data; name="%s"' % key,
'',
value,
])
# Now add the file itself
file_name = os.path.basename(file_path)
f = open(file_path)
file_content = f.read()
f.close()
body.extend(
['--' + BOUNDARY,
'Content-Disposition: form-data; name="filename"; filename="%s"'
% file_name,
# The upload server determines the mime-type, no need to set it.
'Content-Type: application/octet-stream',
'',
file_content,
])
# Finalize the form body
body.extend(['--' + BOUNDARY + '--', ''])
return 'multipart/form-data; boundary=%s' % BOUNDARY, CRLF.join(body)
def main():
parser = optparse.OptionParser(usage='googlecode-upload.py -s SUMMARY '
'-p PROJECT -u USERNAME FILE')
parser.add_option('-s', '--summary', dest='summary',
help='Short description of the file')
parser.add_option('-p', '--project', dest='project',
help='Google Code project name')
parser.add_option('-u', '--user', dest='user',
help='Your Google Code username')
parser.add_option('-l', '--labels', dest='labels',
help='An optional list of labels to attach to the file')
options, args = parser.parse_args()
if not options.summary:
parser.error('File summary is missing.')
elif not options.project:
parser.error('Project name is missing.')
elif not options.user:
parser.error('User name is missing.')
elif len(args) < 1:
parser.error('File to upload not provided.')
print 'Please enter your googlecode.com password.'
print '** Note that this is NOT your Gmail account password! **'
print 'It is the password you use to access Subversion repositories,'
print 'and can be found here: http://code.google.com/hosting/settings'
password = getpass.getpass()
file_path = args[0]
if options.labels:
labels = options.labels.split(',')
else:
labels = None
status, reason, url = upload(file_path, options.project,
options.user, password,
options.summary, labels)
if url:
print 'The file was uploaded successfully.'
print 'URL: %s' % url
else:
print 'An error occurred. Your file was not uploaded.'
print 'Google Code upload server said: %s (%s)' % (reason, status)
if __name__ == '__main__':
main()
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.